Importando CommonCrypto em uma estrutura Swift

Como você importa CommonCryptoem uma estrutura Swift para iOS?

Entendo como usar CommonCryptoem um aplicativo Swift: você adiciona #import <CommonCrypto/CommonCrypto.h>ao cabeçalho da ponte. No entanto, as estruturas Swift não suportam pontes de cabeçalho. A documentação diz:

Você pode importar estruturas externas que possuem uma base de código Objective-C pura, uma base de código Swift pura ou uma base de código em idioma misto. O processo para importar uma estrutura externa é o mesmo, seja ela escrita em um único idioma ou contenha arquivos dos dois idiomas. Ao importar uma estrutura externa, verifique se a configuração de criação do Módulo Defines para a estrutura que você está importando está definida como Sim.

Você pode importar uma estrutura para qualquer arquivo Swift dentro de um destino diferente usando a seguinte sintaxe:

import FrameworkName

Infelizmente, a importação CommonCryptonão funciona. Nem adicionar #import <CommonCrypto/CommonCrypto.h>ao cabeçalho do guarda-chuva.

Algo um pouco mais simples e mais robusto é criar um destino Agregado chamado "CommonCryptoModuleMap" com uma fase Executar Script para gerar o mapa do módulo automaticamente e com o caminho Xcode / SDK correto:

A fase Executar Script deve conter este bash:

# This if-statement means we'll only run the main script if the CommonCryptoModuleMap directory doesn't exist
# Because otherwise the rest of the script causes a full recompile for anything where CommonCrypto is a dependency
# Do a "Clean Build Folder" to remove this directory and trigger the rest of the script to run
if [ -d "${BUILT_PRODUCTS_DIR}/CommonCryptoModuleMap" ]; then
    echo "${BUILT_PRODUCTS_DIR}/CommonCryptoModuleMap directory already exists, so skipping the rest of the script."
    exit 0
fi

mkdir -p "${BUILT_PRODUCTS_DIR}/CommonCryptoModuleMap"
cat <<EOF > "${BUILT_PRODUCTS_DIR}/CommonCryptoModuleMap/module.modulemap"
module CommonCrypto [system] {
    header "${SDKROOT}/usr/include/CommonCrypto/CommonCrypto.h"
    export *
}
EOF

Usar código shell e ${SDKROOT}significa que você não precisa codificar o caminho Xcode.app, que pode variar de sistema para sistema, especialmente se você xcode-selectalternar para uma versão beta ou se estiver construindo em um servidor de IC em que várias versões estão instaladas em locais fora do padrão. Você também não precisa codificar o SDK, portanto isso deve funcionar para iOS, macOS etc. Você também não precisa ter nada no diretório de origem do seu projeto.

Após criar esse destino, faça com que sua biblioteca / estrutura dependa dele com um item de Dependências de Destino:

Isso garantirá que o mapa do módulo seja gerado antes da construção da sua estrutura.

Nota para o macOS : se você também oferece suporte macOS, será necessário adicionar macosxà Supported Platformsconfiguração de compilação o novo destino agregado que você acabou de criar, caso contrário, ele não colocará o mapa do módulo na Debugpasta de dados derivados correta com o restante do produtos de estrutura.

Em seguida, adicione o diretório pai do mapa do módulo ${BUILT_PRODUCTS_DIR}/CommonCryptoModuleMap, à configuração de compilação "Import Paths" na seção Swift ( SWIFT_INCLUDE_PATHS):

Lembre-se de adicionar uma $(inherited)linha se você tiver caminhos de pesquisa definidos no nível do projeto ou xcconfig.

É isso aí, agora você deve ser capaz de import CommonCrypto

Atualização para o Xcode 10

O Xcode 10 agora vem com um mapa de módulo CommonCrypto, tornando essa solução desnecessária. Se você deseja dar suporte ao Xcode 9 e 10, faça uma verificação na fase Executar Script para ver se o mapa do módulo existe ou não, por exemplo

COMMON_CRYPTO_DIR="${SDKROOT}/usr/include/CommonCrypto"
if [ -f "${COMMON_CRYPTO_DIR}/module.modulemap" ]
then
   echo "CommonCrypto already exists, skipping"
else
    # generate the module map, using the original code above
fi

Você pode realmente criar uma solução que "simplesmente funcione" (não é necessário copiar um module.modulemap e SWIFT_INCLUDE_PATHSconfigurações para o seu projeto, conforme exigido por outras soluções aqui), mas requer que você crie uma estrutura / módulo fictício que você ' Importar para sua estrutura adequada. Também podemos garantir que ele funciona independentemente da plataforma ( iphoneos, iphonesimulatorou macosx).

1. Adicione um novo destino de estrutura ao seu projeto e nomeie-o após a biblioteca do sistema, por exemplo , "CommonCrypto". (Você pode excluir o cabeçalho do guarda-chuva, CommonCrypto.h .)

2. Adicione um novo arquivo de configurações e nomeie-o, por exemplo , "CommonCrypto.xcconfig". (Não marque nenhum dos seus alvos para inclusão.) Preencha-o com o seguinte:

   MODULEMAP_FILE[sdk=iphoneos*]        = \
       $(SRCROOT)/CommonCrypto/iphoneos.modulemap
   MODULEMAP_FILE[sdk=iphonesimulator*] = \
       $(SRCROOT)/CommonCrypto/iphonesimulator.modulemap
   MODULEMAP_FILE[sdk=macosx*]          = \
       $(SRCROOT)/CommonCrypto/macosx.modulemap
   

3. Crie os três arquivos de mapa do módulo referenciado acima e preencha-os com o seguinte:

   • iphoneos.modulemap

     module CommonCrypto [system] {
         header "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/usr/include/CommonCrypto/CommonCrypto.h"
         export *
     }
     

   • iphonesimulator.modulemap

     module CommonCrypto [system] {
         header "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk/usr/include/CommonCrypto/CommonCrypto.h"
         export *
     }
     

   • macosx.modulemap

     module CommonCrypto [system] {
         header "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/usr/include/CommonCrypto/CommonCrypto.h"
         export *
     }
     

   (Substitua "Xcode.app" por "Xcode-beta.app" se você estiver executando uma versão beta. Substitua 10.11pelo seu atual SDK do sistema operacional se não estiver executando o El Capitan.)

4. Na guia Informações das configurações do seu projeto, em Configurações , defina as configurações de Depuração e Liberação do CommonCrypto para CommonCrypto (referenciando CommonCrypto.xcconfig ).

5. Na guia Fases de Construção do seu destino da estrutura , adicione a estrutura CommonCrypto às Dependências de Destino . Além disso, adicione libcommonCrypto.dylib à fase de construção Link Binary With Libraries .

6. Selecione CommonCrypto.framework em Produtos e verifique se a Associação de Destino do seu wrapper está definida como Opcional .

Agora você deve poder construir, executar e import CommonCryptoem sua estrutura de wrapper.

Por exemplo, veja como o SQLite.swift usa um sqlite3.framework fictício .

Encontrei um projeto do GitHub que usa com êxito o CommonCrypto em uma estrutura Swift: SHA256-Swift . Além disso, este artigo sobre o mesmo problema com o sqlite3 foi útil.

Com base no acima, as etapas são:

1) Crie um CommonCryptodiretório dentro do diretório do projeto. Dentro, crie um module.maparquivo. O mapa do módulo nos permitirá usar a biblioteca CommonCrypto como um módulo no Swift. Seu conteúdo é:

module CommonCrypto [system] {
    header "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator8.0.sdk/usr/include/CommonCrypto/CommonCrypto.h"
    link "CommonCrypto"
    export *
}

2) Em Configurações de compilação, no Swift Compiler - Caminhos de pesquisa , adicione o CommonCryptodiretório a Importar caminhos ( SWIFT_INCLUDE_PATHS).

3) Por fim, importe o CommonCrypto dentro dos seus arquivos Swift como qualquer outro módulo. Por exemplo:

import CommonCrypto

extension String {

    func hnk_MD5String() -> String {
        if let data = self.dataUsingEncoding(NSUTF8StringEncoding)
        {
            let result = NSMutableData(length: Int(CC_MD5_DIGEST_LENGTH))
            let resultBytes = UnsafeMutablePointer<CUnsignedChar>(result.mutableBytes)
            CC_MD5(data.bytes, CC_LONG(data.length), resultBytes)
            let resultEnumerator = UnsafeBufferPointer<CUnsignedChar>(start: resultBytes, length: result.length)
            let MD5 = NSMutableString()
            for c in resultEnumerator {
                MD5.appendFormat("%02x", c)
            }
            return MD5
        }
        return ""
    }
}

Limitações

O uso da estrutura personalizada em outro projeto falha no tempo de compilação com o erro missing required module 'CommonCrypto'. Isso ocorre porque o módulo CommonCrypto não parece estar incluído na estrutura personalizada. Uma solução alternativa é repetir a etapa 2 (configuração Import Paths) no projeto que usa a estrutura.

O mapa do módulo não é independente da plataforma (atualmente aponta para uma plataforma específica, o iOS 8 Simulator). Não sei como fazer o caminho do cabeçalho em relação à plataforma atual.

Atualizações para iOS 8 <= Devemos remover o link da linha "CommonCrypto" , para obter a compilação bem-sucedida.

ATUALIZAÇÃO / EDIÇÃO

Continuei recebendo o seguinte erro de compilação:

ld: biblioteca não encontrada para -lCommonCrypto para arquitetura x86_64 clang: error: erro do linker com o código de saída 1 (use -v para ver a chamada)

A menos que eu tenha removido a linha link "CommonCrypto"do module.maparquivo que criei. Depois que eu removi esta linha, ela construiu ok.

Esta resposta discute como fazê-lo funcionar dentro de uma estrutura e com Cocoapods e Carthage

Approach abordagem de mapa de módulos

Eu uso modulemapno meu wrapper em torno do CommonCrypto https://github.com/onmyway133/arcane , https://github.com/onmyway133/Reindeer

Para aqueles que estão recebendo header not found, dê uma olhada https://github.com/onmyway133/Arcane/issues/4 ou executexcode-select --install

• Faça uma pasta CCommonCryptocontendomodule.modulemap

    module CCommonCrypto {
      header "/usr/include/CommonCrypto/CommonCrypto.h"
      export *
    }

• Vá para Configurações incorporadas -> Importar caminhos

    ${SRCROOT}/Sources/CCommonCrypto

Ap Cocoapods com abordagem modulemap

• Aqui está o podspec https://github.com/onmyway133/Arcane/blob/master/Arcane.podspec

    s.source_files = 'Sources/**/*.swift'
    s.xcconfig = { 'SWIFT_INCLUDE_PATHS' =>
    '$(PODS_ROOT)/CommonCryptoSwift/Sources/CCommonCrypto' }
    s.preserve_paths = 'Sources/CCommonCrypto/module.modulemap'

• O uso module_mapnão funciona, consulte https://github.com/CocoaPods/CocoaPods/issues/5271

• O uso do Local Development Pod com pathnão funciona, consulte https://github.com/CocoaPods/CocoaPods/issues/809

• É por isso que você vê que meu Podfile de exemplo https://github.com/onmyway133/CommonCrypto.swift/blob/master/Example/CommonCryptoSwiftDemo/Podfile aponta para o repositório git

    target 'CommonCryptoSwiftDemo' do
      pod 'CommonCryptoSwift', :git => 'https://github.com/onmyway133/CommonCrypto.swift'
    end

Header abordagem de cabeçalho público

• Ji é um invólucro em torno da libxml2 e usa a abordagem de cabeçalho público

• Ele tem um arquivo de cabeçalho https://github.com/honghaoz/Ji/blob/master/Source/Ji.h com Target Membershipdefinido comoPublic

• Possui uma lista de arquivos de cabeçalho para libxml2 https://github.com/honghaoz/Ji/tree/master/Source/Ji-libxml

• Possui Configurações de Construção -> Caminhos de Pesquisa de Cabeçalho

    $(SDKROOT)/usr/include/libxml2

• Possui Configurações de Construção -> Outros Sinalizadores de Linker

    -lxml2

Ap Cocoapods com abordagem de cabeçalho público

• Dê uma olhada no podspec https://github.com/honghaoz/Ji/blob/master/Ji.podspec

    s.libraries        = "xml2"
    s.xcconfig         = { 'HEADER_SEARCH_PATHS' =>           '$(SDKROOT)/usr/include/libxml2', 'OTHER_LDFLAGS' => '-lxml2' }

🐝 Postagens relacionadas interessantes

• Como ligar para C da Swift?
• https://spin.atomicobject.com/2015/02/23/c-libraries-swift/

Boas notícias! O Swift 4.2 (Xcode 10) finalmente fornece o CommonCrypto!

Basta adicionar import CommonCryptoseu arquivo rápido.

AVISO: O iTunesConnect pode rejeitar aplicativos que estão usando esse método.

Um novo membro da minha equipe quebrou acidentalmente a solução dada por uma das principais respostas, então decidi consolidá-la em um pequeno projeto de invólucro chamado CommonCryptoModule . Você pode instalá-lo manualmente ou via Cocoapods:

pod 'CommonCryptoModule', '~> 1.0.2'

Então, tudo que você precisa fazer é importar o módulo para onde você precisa CommonCrypto, assim:

import CommonCryptoModule

Espero que alguém ache isso útil.

Eu acho que tenho uma melhoria no excelente trabalho de Mike Weller.

Adicione uma fase Executar Script antes da Compile Sourcesfase que contém este bash:

# This if-statement means we'll only run the main script if the
# CommonCrypto.framework directory doesn't exist because otherwise
# the rest of the script causes a full recompile for anything
# where CommonCrypto is a dependency
# Do a "Clean Build Folder" to remove this directory and trigger
# the rest of the script to run

FRAMEWORK_DIR="${BUILT_PRODUCTS_DIR}/CommonCrypto.framework"

if [ -d "${FRAMEWORK_DIR}" ]; then
echo "${FRAMEWORK_DIR} already exists, so skipping the rest of the script."
exit 0
fi

mkdir -p "${FRAMEWORK_DIR}/Modules"
cat <<EOF > "${FRAMEWORK_DIR}/Modules/module.modulemap"
module CommonCrypto [system] {
    header "${SDKROOT}/usr/include/CommonCrypto/CommonCrypto.h"
    export *
}
EOF

ln -sf "${SDKROOT}/usr/include/CommonCrypto" "${FRAMEWORK_DIR}/Headers"

Este script constrói uma estrutura bare bones com o module.map no local correto e, em seguida, conta com a pesquisa automática de BUILT_PRODUCTS_DIRestruturas do Xcode .

Vinculei a pasta de inclusão CommonCrypto original como a pasta Headers da estrutura, para que o resultado também funcione para projetos de Objetivo C.

Para quem usa o swift 4.2 com o Xcode 10 :

O módulo CommonCrypto agora é fornecido pelo sistema, para que você possa importá-lo diretamente como qualquer outra estrutura do sistema.

import CommonCrypto

O @mogstad teve a gentileza de envolver a solução @stephencelis em um Cocoapod:

pod 'libCommonCrypto'

Os outros pods disponíveis não funcionaram para mim.

As soluções modulemap podem ser boas e robustas contra as alterações do SDK, mas eu as achei difíceis de usar na prática, e não tão confiáveis ​​quanto eu gostaria ao entregar as coisas a outras pessoas. Para tentar tornar tudo mais infalível, segui um caminho diferente:

Basta copiar os cabeçalhos.

Eu sei frágil. Mas a Apple quase nunca faz alterações significativas no CommonCrypto e estou vivendo o sonho de que elas não sejam alteradas de maneira significativa sem também finalmente fazer do CommonCrypto um cabeçalho modular.

Por "copiar os cabeçalhos", quero dizer "recortar e colar todos os cabeçalhos necessários em um cabeçalho maciço no seu projeto, exatamente como o pré-processador faria". Como um exemplo disso que você pode copiar ou adaptar, consulte RNCryptor.h .

Observe que todos esses arquivos são licenciados sob o APSL 2.0, e essa abordagem mantém intencionalmente os avisos de direitos autorais e de licença. Minha etapa de concatenação é licenciada pelo MIT e aplica-se apenas até o próximo aviso de licença).

Não estou dizendo que essa é uma solução bonita, mas até agora parece ter sido uma solução incrivelmente simples para implementar e dar suporte.

Eu sei que esta é uma pergunta antiga. Mas descubro uma maneira alternativa de usar a biblioteca no projeto Swift, que pode ser útil para aqueles que não desejam importar a estrutura introduzida nessas respostas.

No projeto Swift, crie um cabeçalho de ponte Objective-C, crie a categoria NSData (ou classe personalizada para usar a biblioteca) em Objective-C. A única desvantagem seria a necessidade de escrever todo o código de implementação no Objective-C. Por exemplo:

#import "NSData+NSDataEncryptionExtension.h"
#import <CommonCrypto/CommonCryptor.h>

@implementation NSData (NSDataEncryptionExtension)
- (NSData *)AES256EncryptWithKey:(NSString *)key {
    //do something
}

- (NSData *)AES256DecryptWithKey:(NSString *)key {
//do something
}

E, em seguida, no cabeçalho de ponte de objetivo-c, adicione este

#import "NSData+NSDataEncryptionExtension.h"

E então, na classe Swift, faça algo semelhante:

public extension String {
func encryp(withKey key:String) -> String? {
    if let data = self.data(using: .utf8), let encrypedData = NSData(data: data).aes256Encrypt(withKey: key) {
        return encrypedData.base64EncodedString()
    }
    return nil
}
func decryp(withKey key:String) -> String? {
    if let data = NSData(base64Encoded: self, options: []), let decrypedData = data.aes256Decrypt(withKey: key) {
        return decrypedData.UTF8String
    }
    return nil
}
}

Funciona como esperado.

Adicionei alguma mágica de cocoapods à resposta de jjrscott, caso você precise usar o CommonCrypto na sua biblioteca de cocoapods.

1) Adicione esta linha ao seu podspec:

s.script_phase = { :name => 'CommonCrypto', :script => 'sh $PROJECT_DIR/../../install_common_crypto.sh', :execution_position => :before_compile }

2) Salve isso na pasta da biblioteca ou onde quiser (no entanto, não se esqueça de alterar a script_phase de acordo ...)

# This if-statement means we'll only run the main script if the
# CommonCrypto.framework directory doesn't exist because otherwise
# the rest of the script causes a full recompile for anything
# where CommonCrypto is a dependency
# Do a "Clean Build Folder" to remove this directory and trigger
# the rest of the script to run
FRAMEWORK_DIR="${BUILT_PRODUCTS_DIR}/CommonCrypto.framework"

if [ -d "${FRAMEWORK_DIR}" ]; then
echo "${FRAMEWORK_DIR} already exists, so skipping the rest of the script."
exit 0
fi

mkdir -p "${FRAMEWORK_DIR}/Modules"
echo "module CommonCrypto [system] {
    header "${SDKROOT}/usr/include/CommonCrypto/CommonCrypto.h"
    export *
}" >> "${FRAMEWORK_DIR}/Modules/module.modulemap"

ln -sf "${SDKROOT}/usr/include/CommonCrypto" "${FRAMEWORK_DIR}/Headers"

Funciona como um encanto :)

Não tenho certeza se algo mudou com o Xcode 9.2, mas agora é muito mais simples conseguir isso. As únicas coisas que eu precisava fazer eram criar uma pasta chamada "CommonCrypto" no meu diretório de projeto de estrutura e criar dois arquivos dentro dele, um chamado "cc.h" da seguinte maneira:

#include <CommonCrypto/CommonCrypto.h>
#include <CommonCrypto/CommonRandom.h>

E outro chamado module.modulemap:

module CommonCrypto {
    export *
    header "cc.h"
}

(Não sei por que você não pode fazer referência a arquivos de cabeçalho da área SDKROOT diretamente em um arquivo modulemap, mas não consegui fazê-lo funcionar)

A terceira coisa é encontrar a configuração "Import Paths" e definir como $ (SRCROOT). Na verdade, você pode configurá-lo para qualquer pasta em que deseja que a pasta CommonCrypto esteja, se não desejar no nível raiz.

Depois disso, você poderá usar

import CommonCrypto

Em qualquer arquivo rápido e todos os tipos / funções / etc. Estão disponíveis.

Uma palavra de aviso - se seu aplicativo usa libCommonCrypto (ou libcoreCrypto), é excepcionalmente fácil para um hacker não muito sofisticado anexar um depurador ao aplicativo e descobrir quais chaves estão sendo passadas para essas funções.

Caso você tenha o problema abaixo:

ld: biblioteca não encontrada para -lapple_crypto clang: erro: o comando do vinculador falhou com o código de saída 1 (use -v para ver a chamada)

No Xcode 10, Swift 4.0. CommonCrypto faz parte da estrutura.

Adicionar

 import CommonCrypto

Remover

• Arquivo lib CommonCrpto do link binário com bibliotecas das fases de Construção
• import CommonCrypto do cabeçalho de ponte

Isso funcionou para mim!

Aconteceu o mesmo comigo depois de atualizar o Xcode. Eu tentei tudo o que posso fazer, como reinstalar cocoapods e limpar o projeto, mas não funcionou. Agora foi resolvido após reiniciar o sistema.

É muito simples. Adicionar

#import <CommonCrypto/CommonCrypto.h>

para um arquivo .h (o arquivo de cabeçalho de ponte do seu projeto). Como convenção, você pode chamá-lo YourProjectName-Bridging-Header.h.

Em seguida, vá para o seu Build Build Settings e procure Swift Compiler - Code Generation. Abaixo dele, adicione o nome do cabeçalho da ponte à entrada "Objetive-C Bridging Header".

Você Terminou. Nenhuma importação é necessária no seu código Swift. Quaisquer cabeçalhos públicos do Objective-C listados neste arquivo de cabeçalho de ponte serão visíveis para o Swift.