Encapsulamento consiste em traçar limites fortes. Em um navegador web, isso pode significar que seu código para dispositivos móveis não pode ser abusado por outros códigos para dispositivos móveis. No servidor, pode significar a diferenciação entre dados validados e não validados, entre os dados de dois usuários ou entre os dados que os usuários podem ou não acessar.
script-src, img-src, object-src, style_src, font-src, media-src, frame-src, connect-src. Essas oito diretivas usam uma lista de fontes como um valor que especifica domínios que o site pode acessar para um recurso abrangido por essa diretiva. Os desenvolvedores podem usar um curinga * para indicar a totalidade da fonte ou parte dela. Palavras-chave adicionais da lista de fontes, como 'unsafe-inline' e 'unsafe-eval', fornecem um controle mais granular sobre a execução do script, mas são potencialmente prejudiciais. Nenhuma das diretrizes é obrigatória. Os navegadores permitem todas as fontes para uma diretiva não listada ou derivam seu valor da diretiva opcional default-src. Ademais, a especificação para esse cabeçalho tem evoluído ao longo do tempo. Ela foi implementada como X-Content-Security-Policy no Firefox até a versão 23 e no IE até a versão 10, e foi implementada como X-Webkit-CSP no Chrome até a versão 25. Esses dois nomes foram substituídos pelo atual nome padrão Content Security Policy. Dada a quantidade de diretivas, dois nomes alternativos obsoletos, e a forma como várias ocorrências do mesmo cabeçalho e diretivas repetidas em um único cabeçalho são tratados, há uma alta probabilidade de que um desenvolvedor possa configurar mal esse cabeçalho.default-src excessivamente flexível e insegura:
<http auto-config="true">
...
<headers>
...
<content-security-policy policy-directives="default-src '*'" />
</headers>
</http>
script-src, img-src, object-src, style_src, font-src, media-src, frame-src, connect-src. Essas oito diretivas usam uma lista de fontes como um valor que especifica domínios que o site pode acessar para um recurso abrangido por essa diretiva. Os desenvolvedores podem usar um curinga * para indicar a totalidade da fonte ou parte dela. Palavras-chave adicionais da lista de fontes, como 'unsafe-inline' e 'unsafe-eval', fornecem um controle mais granular sobre a execução do script, mas são potencialmente prejudiciais. Nenhuma das diretrizes é obrigatória. Os navegadores permitem todas as fontes para uma diretiva não listada ou derivam seu valor da diretiva opcional default-src. Ademais, a especificação para esse cabeçalho tem evoluído ao longo do tempo. Ela foi implementada como X-Content-Security-Policy no Firefox até a versão 23 e no IE até a versão 10, e foi implementada como X-Webkit-CSP no Chrome até a versão 25. Esses dois nomes foram substituídos pelo atual nome padrão Content Security Policy. Dada a quantidade de diretivas, dois nomes alternativos obsoletos, e a forma como várias ocorrências do mesmo cabeçalho e diretivas repetidas em um único cabeçalho são tratados, há uma alta probabilidade de que um desenvolvedor possa configurar mal esse cabeçalho.*-src foi configurada com uma política excessivamente permissiva, como *Exemplo 1: Esta configuração django-csp define uma diretiva default-src excessivamente permissiva e insegura:
...
MIDDLEWARE = (
...
'csp.middleware.CSPMiddleware',
...
)
...
CSP_DEFAULT_SRC = ("'self'", '*')
...
Access-Control-Allow-Origin é definido. Com esse cabeçalho, um servidor Web define quais outros domínios podem acessar seu domínio usando solicitações entre origens. No entanto, tenha cuidado ao definir o cabeçalho, pois uma política de CORS excessivamente flexível pode permitir que um aplicativo mal-intencionado se comunique inadequadamente com o aplicativo vítima, o que pode levar a falsificação, roubo de dados, retransmissão e outros ataques.
Response.AppendHeader("Access-Control-Allow-Origin", "*");
* como valor do cabeçalho Access-Control-Allow-Origin indica que os dados do aplicativo são acessíveis ao JavaScript em execução em qualquer domínio.Access-Control-Allow-Origin está definido. Com esse cabeçalho, um servidor Web define quais outros domínios podem acessar seu domínio usando solicitações entre origens. No entanto, tenha cuidado ao definir o cabeçalho, pois uma política de CORS excessivamente flexível pode permitir que um aplicativo mal-intencionado se comunique inadequadamente com o aplicativo vítima, o que pode levar a falsificação, roubo de dados, retransmissão e outros ataques.
<websocket:handlers allowed-origins="*">
<websocket:mapping path="/myHandler" handler="myHandler" />
</websocket:handlers>
* como o valor do cabeçalho Access-Control-Allow-Origin indica que os dados do aplicativo podem ser acessados pelo JavaScript em execução em qualquer domínio.Access-Control-Allow-Origin é definido. Com esse cabeçalho, um servidor Web define quais outros domínios podem acessar seu domínio usando solicitações entre origens. No entanto, tenha cuidado ao definir o cabeçalho, pois uma política de CORS excessivamente flexível pode permitir que um aplicativo mal-intencionado se comunique inadequadamente com o aplicativo vítima, o que pode levar a falsificação, roubo de dados, retransmissão e outros ataques.
<?php
header('Access-Control-Allow-Origin: *');
?>
* como valor do cabeçalho Access-Control-Allow-Origin indica que os dados do aplicativo são acessíveis ao JavaScript em execução em qualquer domínio.Access-Control-Allow-Origin é definido. Com esse cabeçalho, um servidor Web define quais outros domínios podem acessar seu domínio usando solicitações entre origens. No entanto, tenha cuidado ao definir o cabeçalho, pois uma política de CORS excessivamente flexível pode permitir que um aplicativo mal-intencionado se comunique inadequadamente com o aplicativo vítima, o que pode levar a falsificação, roubo de dados, retransmissão e outros ataques.
response.addHeader("Access-Control-Allow-Origin", "*")
* como valor do cabeçalho Access-Control-Allow-Origin indica que os dados do aplicativo são acessíveis ao JavaScript em execução em qualquer domínio.Access-Control-Allow-Origin é definido. Com esse cabeçalho, um servidor Web define quais outros domínios podem acessar seu domínio usando solicitações entre origens. No entanto, tenha cuidado ao definir o cabeçalho, pois uma política de CORS excessivamente flexível pode permitir que um aplicativo mal-intencionado se comunique inadequadamente com o aplicativo vítima, o que pode levar a falsificação, roubo de dados, retransmissão e outros ataques.
play.filters.cors {
pathPrefixes = ["/some/path", ...]
allowedOrigins = ["*"]
allowedHttpMethods = ["GET", "POST"]
allowedHttpHeaders = ["Accept"]
preflightMaxAge = 3 days
}
* como valor do cabeçalho Access-Control-Allow-Origin indica que os dados do aplicativo são acessíveis ao JavaScript em execução em qualquer domínio.Access-Control-Allow-Origin é definido. Com esse cabeçalho, um servidor Web define quais outros domínios podem acessar seu domínio usando solicitações entre origens. No entanto, tenha cuidado ao definir o cabeçalho, pois uma política de CORS excessivamente flexível pode permitir que um aplicativo mal-intencionado se comunique inadequadamente com o aplicativo vítima, o que pode levar a falsificação, roubo de dados, retransmissão e outros ataques.
Response.AddHeader "Access-Control-Allow-Origin", "*"
* como valor do cabeçalho Access-Control-Allow-Origin indica que os dados do aplicativo são acessíveis ao JavaScript em execução em qualquer domínio.
WebMessage message = new WebMessage(WEBVIEW_MESSAGE);
webview.postWebMessage(message, Uri.parse("*"));
* como o valor da origem pretendida indica que o script está enviando uma mensagem a uma janela, independentemente da respectiva origem.
o.contentWindow.postMessage(message, '*');
* como o valor da origem pretendida indica que o script está enviando uma mensagem a uma janela, independentemente da respectiva origem.Unsafe-URL, isso poderá fazer com que os aplicativos exponham dados confidenciais de sites e de usuários (incluindo token de sessão, nomes de usuário e senhas) a sites de terceiros.Referrer-Policy é introduzido para controlar o comportamento do navegador em relação ao cabeçalho do referenciador. A opção Unsafe-URL remove todas as restrições e envia o cabeçalho do referenciador com cada solicitação.
<http auto-config="true">
...
<headers>
...
<referrer-policy policy="unsafe-url"/>
</headers>
</http>
Content-Security-Policy-Report-Only fornece a autores e administradores de aplicativos Web a capacidade de monitorar políticas de segurança, em vez de impô-las. Esse cabeçalho geralmente é usado ao serem experimentadas e/ou desenvolvidas políticas de segurança para um site. Quando uma política é considerada efetiva, você pode impô-la usando o campo de cabeçalho Content-Security-Policy.Report-Only:
<http auto-config="true">
...
<headers>
...
<content-security-policy report-only="true" policy-directives="default-src https://content.cdn.example.com" />
</headers>
</http>
Content-Security-Policy-Report-Only fornece a autores e administradores de aplicativos Web a capacidade de monitorar políticas de segurança, em vez de impô-las. Esse cabeçalho geralmente é usado ao serem experimentadas e/ou desenvolvidas políticas de segurança para um site. Quando uma política é considerada efetiva, você pode impô-la usando o cabeçalho Content-Security-Policy.Report-Only:
response.content_security_policy_report_only = "*"
SLComposeServiceViewController isContentValid para validar os dados não confiáveis recebidos antes de usá-los.
#import <MobileCoreServices/MobileCoreServices.h>
@interface ShareViewController : SLComposeServiceViewController
...
@end
@interface ShareViewController ()
...
@end
@implementation ShareViewController
- (void)didSelectPost {
NSExtensionItem *item = self.extensionContext.inputItems.firstObject;
NSItemProvider *itemProvider = item.attachments.firstObject;
...
// Use the received items
...
[self.extensionContext completeRequestReturningItems:@[] completionHandler:nil];
}
...
@end
SLComposeServiceViewController isContentValid para validar os dados não confiáveis recebidos antes de usá-los.SLComposeServiceViewController isContentValid para validá-lo:
import MobileCoreServices
class ShareViewController: SLComposeServiceViewController {
...
override func didSelectPost() {
let extensionItem = extensionContext?.inputItems.first as! NSExtensionItem
let itemProvider = extensionItem.attachments?.first as! NSItemProvider
...
// Use the received items
...
self.extensionContext?.completeRequestReturningItems([], completionHandler:nil)
}
...
}
webview de terceiros usa uma URL para se comunicar com seu aplicativo, o aplicativo receptor deve confrontar o remetente com uma lista de permissões com aplicativos que são esperados para se comunicar com ele. O aplicativo receptor tem a opção de verificar a origem da URL de chamada usando os métodos delegados UIApplicationDelegate application:openURL:options: ou UIApplicationDelegate application:openURL:sourceApplication:annotation:.UIApplicationDelegate application:openURL:options: falha ao verificar o remetente da chamada de IPC e processa apenas a URL de chamada:
- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<NSString *,id> *)options {
NSString *theQuery = [[url query] stringByRemovingPercentEncoding:NSUTF8StringEncoding];
NSArray *chunks = [theQuery componentsSeparatedByString:@"&"];
for (NSString* chunk in chunks) {
NSArray *keyval = [chunk componentsSeparatedByString:@"="]; NSString *key = [keyval objectAtIndex:0];
NSString *value = [keyval objectAtIndex:1];
// Do something with your key and value
}
return YES;
}
wewbview de terceiros usa uma URL para se comunicar com seu aplicativo, o aplicativo receptor deve confrontar o remetente com uma lista de permissões com aplicativos que são esperados para se comunicar com ele. O aplicativo receptor tem a opção de verificar a origem da URL de chamada usando os métodos delegados UIApplicationDelegate application:openURL:options: ou UIApplicationDelegate application:openURL:sourceApplication:annotation:.UIApplicationDelegate application:openURL:options: falha ao verificar o remetente da chamada de IPC e processa apenas a URL de chamada:
func application(app: UIApplication, openURL url: NSURL, options: [String : AnyObject]) -> Bool {
return processCall(url)
}
webview de terceiros usa uma URL para se comunicar com seu aplicativo, o aplicativo receptor deve validar a URL de chamada antes de continuar com outras ações. O aplicativo receptor tem a opção de verificar se ele deseja abrir a URL de chamada usando os métodos delegados UIApplicationDelegate application:didFinishLaunchingWithOptions: ou UIApplicationDelegate application:willFinishLaunchingWithOptions:.UIApplicationDelegate application:didFinishLaunchingWithOptions: falha ao validar a URL de chamada e sempre processa a URL não confiável:
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NS Dictionary *)launchOptions {
return YES;
}
webview de terceiros usa uma URL para se comunicar com seu aplicativo, o aplicativo receptor deve validar a URL de chamada antes de continuar com outras ações. O aplicativo receptor tem a opção de verificar se ele deseja abrir a URL de chamada usando os métodos delegados UIApplicationDelegate application:didFinishLaunchingWithOptions: ou UIApplicationDelegate application:willFinishLaunchingWithOptions:.UIApplicationDelegate application:didFinishLaunchingWithOptions: falha ao validar a URL de chamada e sempre processa a URL não confiável:
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
return true
}
allowBackupcomo true (o valor padrão) e definindo o atributo backupAgent na tag do <application>.Environment.getExternalStorageDirectory() retorna uma referência ao armazenamento externo do dispositivo Android. private void WriteToFile(String what_to_write) {
try{
File root = Environment.getExternalStorageDirectory();
if(root.canWrite()) {
File dir = new File(root + "write_to_the_SDcard");
File datafile = new File(dir, number + ".extension");
FileWriter datawriter = new FileWriter(datafile);
BufferedWriter out = new BufferedWriter(datawriter);
out.write(what_to_write);
out.close();
}
}
}
kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:kSecAttrAccessibleAlways:kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:kSecAttrAccessibleAlwaysThisDeviceOnly:kSecAttrAccessibleWhenUnlocked:kSecAttrAccessibleWhenUnlockedThisDeviceOnly:ThisDeviceOnly serão armazenados em backup no iCloud e no iTunes, mesmo se você estiver usando backups não criptografados que podem ser restaurados para qualquer dispositivo. Dependendo de quão confidenciais e privados os dados armazenados são, isso pode gerar uma preocupação de privacidade.
...
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)kSecAttrAccessibleWhenUnlocked forKey:(__bridge id) kSecAttrAccessible];
OSStatus error = SecItemAdd((__bridge CFDictionaryRef)dict, NULL);
...
kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:kSecAttrAccessibleAlways:kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:kSecAttrAccessibleAlwaysThisDeviceOnly:kSecAttrAccessibleWhenUnlocked:kSecAttrAccessibleWhenUnlockedThisDeviceOnly:ThisDeviceOnly serão armazenados em backup no iCloud e no iTunes, mesmo se você estiver usando backups não criptografados que podem ser restaurados para qualquer dispositivo. Dependendo de quão confidenciais e privados os dados armazenados são, isso pode gerar uma preocupação de privacidade.
...
// Configure KeyChain Item
let token = "secret"
var query = [String : AnyObject]()
query[kSecClass as String] = kSecClassGenericPassword
query[kSecValueData as String] = token as AnyObject?
...
query[kSecAttrAccessible as String] = kSecAttrAccessibleWhenUnlocked
SecItemAdd(query as CFDictionary, nil)
...
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();
}
}
{app ID}/Library/Caches/com.mycompany.myapp/Cache.db*.{app ID}/Library/Caches/com.mycompany.myapp/Cache.db*.{app ID}/Library/Caches/com.mycompany.myapp/Cache.db*. 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.{app ID}/Library/Caches/com.mycompany.myapp/Cache.db*. 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.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:NSFileProtectionCompleteUnlessOpen, NSDataWritingFileProtectionCompleteUnlessOpen:NSFileProtectionCompleteUntilFirstUserAuthentication, NSDataWritingFileProtectionCompleteUntilFirstUserAuthentication:NSFileProtectionNone, NSDataWritingFileProtectionNone: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 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];
...
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];
...
...
filepath = [self.GetDocumentDirectory stringByAppendingPathComponent:self.setFilename];
...
NSData *textData = [textToWrite dataUsingEncoding:NSUnicodeStingEncoding];
...
BOOL ok = [textData writeToFile:filepath options:NSDataWritingFileProtectionCompleteUntilFirstUserAuthentication error:&err];
...
NSFileManager como constantes que devem ser atribuídas como o valor da chave NSFileProtectionKey em um Dictionary 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 NSFileManager, incluindo setAttributes(_:ofItemAtPath:), attributesOfItemAtPath(_:) e createFileAtPath(_:contents:attributes:). Além disso, as constantes correspondentes de Proteção de dados são definidas para objetos NSData na enumeração NSDataWritingOptions que podem ser transmitidas como o argumento options para as funções NSData
writeToFile(_:options:)NSFileManager e do NSData são as seguintes:NSFileProtectionComplete, NSDataWritingOptions.DataWritingFileProtectionComplete:NSFileProtectionCompleteUnlessOpen, NSDataWritingOptions.DataWritingFileProtectionCompleteUnlessOpen:NSFileProtectionCompleteUntilFirstUserAuthentication, NSDataWritingOptions.DataWritingFileProtectionCompleteUntilFirstUserAuthentication:NSFileProtectionNone, NSDataWritingOptions.DataWritingFileProtectionNone: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 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):
...
let documentsPath = NSURL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0])
let filename = "\(documentsPath)/tmp_activeTrans.txt"
let protection = [NSFileProtectionKey: NSFileProtectionCompleteUntilFirstUserAuthentication]
do {
try NSFileManager.defaultManager().setAttributes(protection, ofItemAtPath: filename)
} catch let error as NSError {
NSLog("Unable to change attributes: \(error.debugDescription)")
}
...
BOOL ok = textToWrite.writeToFile(filename, atomically:true)
...
...
let documentsPath = NSURL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0])
let filename = "\(documentsPath)/tmp_activeTrans.txt"
...
BOOL ok = textData.writeToFile(filepath, options: .DataWritingFileProtectionCompleteUntilFirstUserAuthentication);
...
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:kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:kSecAttrAccessibleAlways:kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:kSecAttrAccessibleAlwaysThisDeviceOnly:kSecAttrAccessibleWhenUnlocked:kSecAttrAccessibleWhenUnlockedThisDeviceOnly: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.
...
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);
...
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:kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:kSecAttrAccessibleAlways:kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:kSecAttrAccessibleAlwaysThisDeviceOnly:kSecAttrAccessibleWhenUnlocked:kSecAttrAccessibleWhenUnlockedThisDeviceOnly: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.
...
// Configure KeyChain Item
let token = "secret"
var query = [String : AnyObject]()
query[kSecClass as String] = kSecClassGenericPassword
query[kSecValueData as String] = token as AnyObject?
...
query[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
SecItemAdd(query as CFDictionary, nil)
...
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:NSFileProtectionCompleteUnlessOpen, NSDataWritingFileProtectionCompleteUnlessOpen:NSFileProtectionCompleteUntilFirstUserAuthentication, NSDataWritingFileProtectionCompleteUntilFirstUserAuthentication:NSFileProtectionNone, NSDataWritingFileProtectionNone: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 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];
...
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];
...
...
filepath = [self.GetDocumentDirectory stringByAppendingPathComponent:self.setFilename];
...
NSData *textData = [textToWrite dataUsingEncoding:NSUnicodeStingEncoding];
...
BOOL ok = [textData writeToFile:filepath options:NSDataWritingFileProtectionNone error:&err];
...
NSFileManager como constantes que devem ser atribuídas como o valor da chave NSFileProtectionKey em um Dictionary associado à instância do NSFileManager. 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:), attributesOfItemAtPath(_:) e createFileAtPath(_:contents:attributes:). Além disso, as constantes correspondentes de Proteção de dados são definidas para objetos NSData na enumeração NSDataWritingOptions que podem ser transmitidas como o argumento options para as funções NSData como
writeToFile(_:options:)NSFileManager e do NSData são as seguintes:NSFileProtectionComplete, NSDataWritingOptions.DataWritingFileProtectionComplete:NSFileProtectionCompleteUnlessOpen, NSDataWritingOptions.DataWritingFileProtectionCompleteUnlessOpen:NSFileProtectionCompleteUntilFirstUserAuthentication, NSDataWritingOptions.DataWritingFileProtectionCompleteUntilFirstUserAuthentication:NSFileProtectionNone, NSDataWritingOptions.DataWritingFileProtectionNone: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 2: Neste exemplo, os dados não estão protegidos (são acessíveis a qualquer momento em que o dispositivo estiver ligado):
...
let documentsPath = NSURL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0])
let filename = "\(documentsPath)/tmp_activeTrans.txt"
let protection = [NSFileProtectionKey: NSFileProtectionNone]
do {
try NSFileManager.defaultManager().setAttributes(protection, ofItemAtPath: filename)
} catch let error as NSError {
NSLog("Unable to change attributes: \(error.debugDescription)")
}
...
BOOL ok = textToWrite.writeToFile(filename, atomically:true)
...
...
let documentsPath = NSURL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0])
let filename = "\(documentsPath)/tmp_activeTrans.txt"
...
BOOL ok = textData.writeToFile(filepath, options: .DataWritingFileProtectionNone);
...
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:kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:kSecAttrAccessibleAlways:kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:kSecAttrAccessibleAlwaysThisDeviceOnly:kSecAttrAccessibleWhenUnlocked:kSecAttrAccessibleWhenUnlockedThisDeviceOnly: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.
...
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);
...
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:kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly:kSecAttrAccessibleAlways:kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly:kSecAttrAccessibleAlwaysThisDeviceOnly:kSecAttrAccessibleWhenUnlocked:kSecAttrAccessibleWhenUnlockedThisDeviceOnly: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.
...
// Configure KeyChain Item
let token = "secret"
var query = [String : AnyObject]()
query[kSecClass as String] = kSecClassGenericPassword
query[kSecValueData as String] = token as AnyObject?
...
query[kSecAttrAccessible as String] = kSecAttrAccessibleAlways
SecItemAdd(query as CFDictionary, nil)
...