Importazione di CommonCrypto in un framework Swift

Come si importa CommonCryptoin un framework Swift per iOS?

Capisco come utilizzare CommonCryptoin un'app Swift: aggiungi #import <CommonCrypto/CommonCrypto.h>all'intestazione ponte. Tuttavia, i framework Swift non supportano il bridging delle intestazioni. La documentazione dice:

È possibile importare framework esterni che hanno una base di codice Objective-C pura, una base di codice Swift pura o una base di codice in linguaggio misto. Il processo per importare un framework esterno è lo stesso sia che il framework sia scritto in una sola lingua o contenga file da entrambe le lingue. Quando si importa un framework esterno, assicurarsi che l'impostazione di compilazione del modulo Definisci per il framework che si sta importando sia impostata su Sì.

Puoi importare un framework in qualsiasi file Swift all'interno di una destinazione diversa usando la sintassi seguente:

import FrameworkName

Sfortunatamente, l'importazione CommonCryptonon funziona. Né si aggiunge #import <CommonCrypto/CommonCrypto.h>all'intestazione dell'ombrello.

Qualcosa di un po 'più semplice e robusto è creare un target aggregato chiamato "CommonCryptoModuleMap" con una fase Run Script per generare automaticamente la mappa del modulo e con il percorso Xcode / SDK corretto:

La fase Run Script dovrebbe contenere questo 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

L'uso del codice shell e ${SDKROOT}significa che non è necessario codificare il percorso Xcode.app che può variare da sistema a sistema, specialmente se si utilizza xcode-selectper passare a una versione beta o si sta costruendo su un server CI in cui sono installate più versioni in posizioni non standard. Inoltre, non è necessario codificare l'SDK in modo rigido, quindi dovrebbe funzionare per iOS, macOS, ecc. Inoltre, non è necessario disporre di alcun elemento nella directory di origine del progetto.

Dopo aver creato questo target, fai in modo che la tua libreria / framework dipenda da esso con un elemento Dipendenze target:

Ciò garantirà che la mappa del modulo venga generata prima della creazione del framework.

nota macOS : se stai supportando macOSanche, dovrai aggiungere macosxl' Supported Platformsimpostazione di build sulla nuova destinazione aggregata appena creata, altrimenti non inserirà la mappa del modulo nella Debugcartella dei dati derivati corretta con il resto del prodotti quadro.

Successivamente, aggiungi la directory principale della mappa del modulo ${BUILT_PRODUCTS_DIR}/CommonCryptoModuleMap, all'impostazione di build "Importa percorsi" nella sezione Swift ( SWIFT_INCLUDE_PATHS):

Ricorda di aggiungere una $(inherited)riga se hai percorsi di ricerca definiti a livello di progetto o xcconfig.

Questo è tutto, ora dovresti essere in grado di farlo import CommonCrypto

Aggiornamento per Xcode 10

Xcode 10 ora viene fornito con una mappa del modulo CommonCrypto che rende superflua questa soluzione alternativa. Se desideri supportare sia Xcode 9 che 10, puoi fare un controllo nella fase Run Script per vedere se la mappa del modulo esiste o no, ad es.

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

Puoi effettivamente creare una soluzione che " funzioni " (non è necessario copiare un modulo modulo e SWIFT_INCLUDE_PATHSimpostazioni sul tuo progetto, come richiesto da altre soluzioni qui), ma richiede di creare un framework / modulo fittizio che " Importerò nel tuo framework. Possiamo anche assicurare che funziona indipendentemente dalla piattaforma ( iphoneos, iphonesimulator, o macosx).

1. Aggiungi un nuovo target di framework al tuo progetto e chiamalo come la libreria di sistema, ad esempio "CommonCrypto". (È possibile eliminare l'intestazione dell'ombrello, CommonCrypto.h .)

2. Aggiungere un nuovo file delle impostazioni di configurazione e denominarlo, ad esempio "CommonCrypto.xcconfig". (Non controllare nessuno dei tuoi target per l'inclusione.) Popolarlo con il seguente:

   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. Creare i tre file delle mappe dei moduli di riferimento sopra riportati e popolarli con quanto segue:

   • 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 *
     }

   (Sostituisci "Xcode.app" con "Xcode-beta.app" se esegui una versione beta. Sostituisci 10.11con il tuo attuale SDK del sistema operativo se non esegui El Capitan.)

4. Nella scheda Informazioni delle impostazioni del progetto, in Configurazioni , imposta le configurazioni Debug e Release di CommonCrypto su CommonCrypto (facendo riferimento a CommonCrypto.xcconfig ).

5. Nella scheda Costruisci fasi del target del framework , aggiungere il framework CommonCrypto alle dipendenze del target . Inoltre aggiungi libcommonCrypto.dylib alla fase di costruzione di Link Binary With Libraries .

6. Seleziona CommonCrypto.framework in Prodotti e assicurati che il suo abbonamento di destinazione per il tuo wrapper sia impostato su Opzionale .

Ora dovresti essere in grado di creare, eseguire e import CommonCrypto nel tuo framework wrapper.

Per un esempio, vedere come SQLite.swift utilizza un fittizio sqlite3.framework .

Ho trovato un progetto GitHub che utilizza correttamente CommonCrypto in un framework Swift: SHA256-Swift . Inoltre, questo articolo riguarda lo stesso problema con sqlite3 stato utile.

Sulla base di quanto sopra, i passaggi sono:

1) Creare una CommonCryptodirectory all'interno della directory del progetto. All'interno, crea un module.mapfile. La mappa del modulo ci consentirà di utilizzare la libreria CommonCrypto come modulo all'interno di Swift. I suoi contenuti sono:

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) In Build Settings, all'interno di Swift Compiler - Search Paths , aggiungi la CommonCryptodirectory a Import Paths ( SWIFT_INCLUDE_PATHS).

3) Infine, importa CommonCrypto all'interno dei tuoi file Swift come qualsiasi altro modulo. Per esempio:

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 ""
    }
}

limitazioni

L'uso del framework personalizzato in un altro progetto non riesce in fase di compilazione con l'errore missing required module 'CommonCrypto'. Questo perché il modulo CommonCrypto non sembra essere incluso con il framework personalizzato. Una soluzione alternativa è ripetere il passaggio 2 (impostazione Import Paths) nel progetto che utilizza il framework.

La mappa del modulo non è indipendente dalla piattaforma (attualmente punta a una piattaforma specifica, il simulatore iOS 8). Non so come rendere il percorso dell'intestazione relativo alla piattaforma corrente.

Aggiornamenti per iOS 8 <= Dovremmo rimuovere il collegamento di linea "CommonCrypto" , per ottenere la compilazione corretta.

AGGIORNAMENTO / MODIFICA

Continuavo a ricevere il seguente errore di build:

ld: libreria non trovata per -lCommonCrypto per architettura x86_64 clang: errore: comando linker non riuscito con il codice di uscita 1 (usare -v per vedere l'invocazione)

A meno che non ho rimosso la linea link "CommonCrypto"dal module.mapfile che ho creato. Una volta rimossa questa riga, ha funzionato bene.

Questa risposta spiega come farlo funzionare all'interno di un framework e con Cocoapods e Carthage

Approach approccio modulemap

Uso modulemapnel mio wrapper attorno a CommonCrypto https://github.com/onmyway133/arcane , https://github.com/onmyway133/Reindeer

Per chi lo riceve header not found, dai un'occhiata a https://github.com/onmyway133/Arcane/issues/4 o corrixcode-select --install

• Crea una cartella CCommonCryptocontenentemodule.modulemap

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

• Vai a Impostazioni integrate -> Importa percorsi

    ${SRCROOT}/Sources/CCommonCrypto

🌳 Cocoapods con approccio modulemap

• Ecco il 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'

• L'uso module_mapnon funziona, consultare https://github.com/CocoaPods/CocoaPods/issues/5271

• L'uso del Pod di sviluppo locale con pathnon funziona, consultare https://github.com/CocoaPods/CocoaPods/issues/809

• Ecco perché vedi che il mio esempio Podfile https://github.com/onmyway133/CommonCrypto.swift/blob/master/Example/CommonCryptoSwiftDemo/Podfile punta al repository git

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

Approach approccio di intestazione pubblica

• Ji è un wrapper per libxml2 e utilizza un approccio di intestazione pubblica

• Ha un file di intestazione https://github.com/honghaoz/Ji/blob/master/Source/Ji.h con Target Membershipimpostato suPublic

• Ha un elenco di file di intestazione per libxml2 https://github.com/honghaoz/Ji/tree/master/Source/Ji-libxml

• Ha le impostazioni di costruzione -> Percorsi di ricerca dell'intestazione

    $(SDKROOT)/usr/include/libxml2

• Ha le impostazioni di costruzione -> Altre bandiere linker

    -lxml2

🐏 Cocoapods con approccio di intestazione pubblica

• Dai un'occhiata al 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' }

🐝 Post correlati interessanti

• Come chiamare C da Swift?
• https://spin.atomicobject.com/2015/02/23/c-libraries-swift/

Buone notizie! Swift 4.2 (Xcode 10) fornisce finalmente CommonCrypto!

Aggiungi semplicemente il import CommonCryptotuo file rapido.

ATTENZIONE: iTunesConnect potrebbe rifiutare le app che utilizzano questo metodo.

Un nuovo membro del mio team ha rotto per errore la soluzione fornita da una delle risposte migliori, quindi ho deciso di consolidarla in un piccolo progetto wrapper chiamato CommonCryptoModule . Puoi installarlo manualmente o tramite Cocoapods:

pod 'CommonCryptoModule', '~> 1.0.2'

Quindi, tutto ciò che devi fare è importare il modulo dove ti serve CommonCrypto, in questo modo:

import CommonCryptoModule

Spero che qualcun altro lo trovi utile.

Penso di avere migliorato l'eccellente lavoro di Mike Weller.

Aggiungi una fase Run Script prima della Compile Sourcesfase che contiene questo 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"

Questo script costruisce un framework bare bones con module.map nella posizione corretta e quindi si basa sulla ricerca automatica di Xcode di BUILT_PRODUCTS_DIR per framework.

Ho collegato la cartella include CommonCrypto originale come cartella Intestazioni del framework, quindi il risultato dovrebbe funzionare anche per i progetti Obiettivo C.

Per chiunque usi swift 4.2 con Xcode 10 :

Il modulo CommonCrypto è ora fornito dal sistema, quindi è possibile importarlo direttamente come qualsiasi altro framework di sistema.

import CommonCrypto

@mogstad è stato così gentile da avvolgere la soluzione @stephencelis in un Cocoapod:

pod 'libCommonCrypto'

Gli altri pod disponibili non hanno funzionato per me.

Le soluzioni modulemap possono essere buone e robuste rispetto alle modifiche dell'SDK, ma le ho trovate scomode da usare in pratica e non affidabili come vorrei quando distribuivo le cose ad altri. Per provare a rendere tutto più sicuro, sono andato in un altro modo:

Copia le intestazioni.

Lo so, fragile. Ma Apple non fa quasi mai modifiche significative a CommonCrypto e sto vivendo il sogno che non lo cambieranno in modo significativo senza rendere infine CommonCrypto un'intestazione modulare.

Con "copia le intestazioni" intendo "taglia e incolla tutte le intestazioni di cui hai bisogno in un'unica enorme intestazione nel tuo progetto, proprio come farebbe il preprocessore". Come esempio di ciò che è possibile copiare o adattare, vedere RNCryptor.h .

Si noti che tutti questi file sono concessi in licenza in base a APSL 2.0 e questo approccio mantiene intenzionalmente le informazioni sul copyright e sulla licenza. Il mio passaggio di concatenazione è concesso in licenza in base al MIT e questo vale solo fino al prossimo avviso di licenza).

Non sto dicendo che questa sia una soluzione meravigliosa, ma finora sembra essere stata una soluzione incredibilmente semplice da implementare e supportare.

So che questa è una vecchia domanda. Ma ho scoperto un modo alternativo di utilizzare la libreria nel progetto Swift, che potrebbe essere utile per coloro che non vogliono importare il framework introdotto in queste risposte.

Nel progetto Swift, creare un'intestazione di bridge Objective-C, creare la categoria NSData (o classe personalizzata per utilizzare la libreria) in Objective-C. L'unico inconveniente sarebbe che devi scrivere tutto il codice di implementazione in Objective-C. Per esempio:

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

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

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

E poi nella tua intestazione ponte obiettivo-c, aggiungi questo

#import "NSData+NSDataEncryptionExtension.h"

E poi nella classe Swift fai una cosa simile:

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
}
}

Funziona come previsto.

Ho aggiunto un po 'di magia dei cocoapodi alla risposta di jjrscott nel caso in cui tu abbia bisogno di usare CommonCrypto nella tua libreria di cocoapodi.

1) Aggiungi questa linea al tuo podspec:

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

2) Salvalo nella cartella della libreria o dove preferisci (tuttavia non dimenticare di modificare di conseguenza la fase script ...)

# 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"

Funziona come un fascino :)

Non sono sicuro che qualcosa sia cambiato con Xcode 9.2 ma ora è molto più semplice farlo. Le uniche cose che dovevo fare sono creare una cartella chiamata "CommonCrypto" nella directory del mio progetto quadro e creare due file al suo interno, uno chiamato "cc.h" come segue:

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

E un altro chiamato module.modulemap:

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

(Non so perché non è possibile fare riferimento ai file di intestazione dall'area SDKROOT direttamente in un file modulemap ma non sono riuscito a farlo funzionare)

La terza cosa è trovare l'impostazione "Importa percorsi" e impostare su $ (SRCROOT). In effetti è possibile impostarlo su qualsiasi cartella in cui si desidera posizionare la cartella CommonCrypto, se non lo si desidera a livello di root.

Dopo questo dovresti essere in grado di usare

import CommonCrypto

In qualsiasi file rapido e tutti i tipi / funzioni / ecc. sono disponibili.

Un avvertimento però: se la tua app utilizza libCommonCrypto (o libcoreCrypto) è eccezionalmente facile per un hacker non troppo sofisticato collegare un debugger alla tua app e scoprire quali chiavi vengono passate a queste funzioni.

Nel caso in cui hai il seguente problema:

ld: libreria non trovata per -lapple_crypto clang: errore: comando linker non riuscito con codice di uscita 1 (usare -v per vedere l'invocazione)

In Xcode 10, Swift 4.0. CommonCrypto è una parte del framework.

Inserisci

 import CommonCrypto

Rimuovere

• CommonCrpto lib file dal collegamento binario con librerie dalle fasi di compilazione
• import CommonCrypto dall'intestazione Bridging

Questo ha funzionato per me!

Mi è successo lo stesso dopo aver aggiornato Xcode. Ho provato tutto ciò che posso fare, come reinstallare i cocoapodi e pulire il progetto, ma non ha funzionato. Ora è stato risolto dopo il riavvio del sistema.

È molto semplice. Inserisci

#import <CommonCrypto/CommonCrypto.h>

in un file .h (il file di intestazione ponte del progetto). Come convenzione puoi chiamarlo YourProjectName-Bridging-Header.h.

Quindi vai al tuo progetto Build Settings e cerca Swift Compiler - Code Generation. Sotto di esso, aggiungi il nome della tua intestazione ponte alla voce "Intestazione ponte Objetive-C".

Hai finito. Nessuna importazione richiesta nel tuo codice Swift. Tutte le intestazioni pubbliche di Objective-C elencate in questo file di intestazione ponte saranno visibili a Swift.