Importowanie CommonCrypto w ramach Swift

Jak importować CommonCryptow środowisku Swift na iOS?

Rozumiem, jak używać CommonCryptow aplikacji Swift: dodajesz #import <CommonCrypto/CommonCrypto.h>do nagłówka pomostowego. Jednak frameworki Swift nie obsługują mostkowania nagłówków. Dokumentacja mówi:

Możesz importować zewnętrzne frameworki, które mają czystą bazę kodową Objective-C, czystą bazę kodową Swift lub bazę kodową w języku mieszanym. Proces importowania zewnętrznego frameworka jest taki sam, niezależnie od tego, czy frameworku jest napisany w jednym języku, czy zawiera pliki z obu języków. Podczas importowania frameworka zewnętrznego upewnij się, że ustawienie kompilacji modułu Definiuje dla importowanej frameworku jest ustawione na Tak.

Możesz zaimportować strukturę do dowolnego pliku Swift w innym celu za pomocą następującej składni:

import FrameworkName

Niestety import CommonCryptonie działa. Nie dodaje się również #import <CommonCrypto/CommonCrypto.h>do nagłówka parasola.

Coś nieco prostszego i bardziej niezawodnego polega na utworzeniu celu agregującego o nazwie „CommonCryptoModuleMap” z fazą Run Script w celu automatycznego wygenerowania mapy modułów i prawidłowej ścieżki Xcode / SDK:

Faza Uruchom skrypt powinna zawierać ten 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

Używanie kodu powłoki i ${SDKROOT}oznacza, że ​​nie musisz kodować na stałe ścieżki Xcode.app, która może różnić się w zależności od systemu, szczególnie jeśli używasz xcode-selectdo przejścia do wersji beta lub budujesz na serwerze CI, na którym zainstalowanych jest wiele wersji w niestandardowych lokalizacjach. Nie musisz też kodować na stałe SDK, więc powinno to działać na iOS, macOS itp. Nie musisz też mieć niczego, co mogłoby znajdować się w katalogu źródłowym twojego projektu.

Po utworzeniu tego celu uzależnij swoją bibliotekę / strukturę za pomocą elementu Zależności docelowe:

Zapewni to wygenerowanie mapy modułów przed zbudowaniem frameworka.

Uwaga dotycząca systemu macOS : jeśli również wspierasz macOS, musisz dodać macosxdo Supported Platformsustawienia kompilacji nowego właśnie utworzonego celu zagregowanego, inaczej nie umieści on mapy modułów w odpowiednim Debugfolderze danych pochodnych wraz z resztą produkty ramowe.

Następnie dodaj katalog nadrzędny mapy modułów ${BUILT_PRODUCTS_DIR}/CommonCryptoModuleMapdo ustawienia kompilacji „Importuj ścieżki” w sekcji Swift ( SWIFT_INCLUDE_PATHS):

Pamiętaj, aby dodać $(inherited)wiersz, jeśli masz ścieżki wyszukiwania zdefiniowane na poziomie projektu lub xcconfig.

To wszystko, powinieneś teraz być w stanie import CommonCrypto

Zaktualizuj Xcode 10

Xcode 10 jest teraz dostarczany z mapą modułów CommonCrypto, dzięki czemu to obejście nie jest konieczne. Jeśli chcesz obsługiwać zarówno Xcode 9, jak i 10, możesz sprawdzić w fazie Run Script, czy mapa modułu istnieje, czy nie, np.

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

Możesz faktycznie zbudować rozwiązanie, które „po prostu działa” (nie musisz kopiować modułu.modulemap i SWIFT_INCLUDE_PATHSustawień do projektu, jak wymagają tego inne rozwiązania tutaj), ale wymaga to stworzenia fałszywego frameworka / modułu, który „ Zaimportuję do twojego frameworka. Możemy również zapewnić, że działa niezależnie od platformy ( iphoneos, iphonesimulatorlub macosx).

1. Dodaj nowy cel struktury do projektu i nazwij go po bibliotece systemowej, np. „CommonCrypto”. (Możesz usunąć nagłówek parasola CommonCrypto.h .)

2. Dodaj nowy plik ustawień konfiguracji i nazwij go, np. „CommonCrypto.xcconfig”. (Nie zaznaczaj żadnego z celów pod kątem włączenia.) Wypełnij go następującymi danymi:

   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. Utwórz trzy wyżej wymienione pliki map modułów i wypełnij je następującymi elementami:

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

   (Jeśli używasz wersji beta, zamień „Xcode.app” na „Xcode-beta.app”. Zastąp 10.11obecny pakiet SDK systemu operacyjnego, jeśli nie używasz El Capitan.)

4. Na Info zakładce ustawień projektu, pod Konfiguracje ustaw Debug i Release konfiguracje CommonCrypto do CommonCrypto (odwołującego CommonCrypto.xcconfig ).

5. Na karcie Fazy ​​kompilacji celu struktury szkieletowej dodaj strukturę CommonCrypto do Zależności docelowych . Dodatkowo dodaj libcommonCrypto.dylib do fazy kompilacji Link Binary With Libraries .

6. Wybierz CommonCrypto.framework w produktach i upewnij się, że jego docelowe członkostwo dla opakowania jest ustawione na opcjonalne .

Powinieneś być teraz w stanie budować, uruchamiać i import CommonCryptow swoim środowisku opakowującym.

Na przykład zobacz, jak SQLite.swift używa fałszywego narzędzia sqlite3.framework .

Znalazłem projekt GitHub, który z powodzeniem wykorzystuje CommonCrypto w środowisku Swift: SHA256-Swift . Przydał się także ten artykuł o tym samym problemie z sqlite3 .

W oparciu o powyższe kroki są następujące:

1) Utwórz CommonCryptokatalog w katalogu projektu. Wewnątrz utwórz module.mapplik. Mapa modułów pozwoli nam korzystać z biblioteki CommonCrypto jako modułu w Swift. Jego zawartość to:

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) W Ustawieniach kompilacji, w Swift Compiler - Search Paths , dodaj CommonCryptokatalog do Importuj ścieżki ( SWIFT_INCLUDE_PATHS).

3) Na koniec zaimportuj CommonCrypto do plików Swift, tak jak inne moduły. Na przykład:

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

Ograniczenia

Użycie niestandardowej struktury w innym projekcie kończy się niepowodzeniem podczas kompilacji z błędem missing required module 'CommonCrypto'. Wynika to z faktu, że moduł CommonCrypto nie wydaje się być dołączany do niestandardowej struktury. Obejściem tego problemu jest powtórzenie kroku 2 (ustawienie Import Paths) w projekcie korzystającym z frameworka.

Mapa modułów nie jest niezależna od platformy (obecnie wskazuje na konkretną platformę, symulator iOS 8). Nie wiem, jak ustawić ścieżkę nagłówka względem bieżącej platformy.

Aktualizacje dla iOS 8 <= Powinniśmy usunąć link do linii „CommonCrypto” , aby uzyskać udaną kompilację.

AKTUALIZACJA / EDYCJA

Wciąż pojawiał się następujący błąd kompilacji:

ld: nie znaleziono biblioteki dla -lCommonCrypto dla architektury x86_64 clang: error: komenda linkera nie powiodła się z kodem wyjścia 1 (użyj -v, aby zobaczyć wywołanie)

Chyba że usunąłem linię link "CommonCrypto"z utworzonego module.mappliku. Kiedy usunąłem tę linię, zbudowała się dobrze.

Ta odpowiedź omawia, jak sprawić, by działał wewnątrz frameworka oraz w Cocoapods i Carthage

Approach podejście modulemap

Używam modulemapw swoim opakowaniu wokół CommonCrypto https://github.com/onmyway133/arcane , https://github.com/onmyway133/Reindeer

Dla tych header not found, którzy dostają , spójrz https://github.com/onmyway133/Arcane/issues/4 lub uruchomxcode-select --install

• Utwórz folder CCommonCryptozawierającymodule.modulemap

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

• Przejdź do Ustawień wbudowanych -> Importuj ścieżki

    ${SRCROOT}/Sources/CCommonCrypto

🌳 Cocoapods z podejściem modulemap

• Oto 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'

• Korzystanie module_mapnie działa, patrz https://github.com/CocoaPods/CocoaPods/issues/5271

• Korzystanie z narzędzia Local Development Pod pathnie działa, patrz https://github.com/CocoaPods/CocoaPods/issues/809

• Właśnie dlatego widzisz, że mój przykład Podfile https://github.com/onmyway133/CommonCrypto.swift/blob/master/Example/CommonCryptoSwiftDemo/Podfile wskazuje na repozytorium git

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

Approach podejście do nagłówka publicznego

• Ji jest opakowaniem wokół libxml2 i wykorzystuje publiczne podejście do nagłówków

• Ma plik nagłówka https://github.com/honghaoz/Ji/blob/master/Source/Ji.h z Target Membershipustawionym naPublic

• Posiada listę plików nagłówkowych dla libxml2 https://github.com/honghaoz/Ji/tree/master/Source/Ji-libxml

• Ma Ustawienia kompilacji -> Ścieżki wyszukiwania nagłówka

    $(SDKROOT)/usr/include/libxml2

• Ma Ustawienia kompilacji -> Inne flagi linkera

    -lxml2

🐏 Cocoapods z publicznym podejściem do nagłówka

• Spójrz na 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' }

🐝 Ciekawe powiązane posty

• Jak zadzwonić do C z Swift?
• https://spin.atomicobject.com/2015/02/23/c-libraries-swift/

Dobre wieści! Swift 4.2 (Xcode 10) wreszcie udostępnia CommonCrypto!

Po prostu dodaj import CommonCryptoswój szybki plik.

OSTRZEŻENIE: iTunesConnect może odrzucać aplikacje korzystające z tej metody.

Nowy członek mojego zespołu przypadkowo złamał rozwiązanie podane przez jedną z najlepszych odpowiedzi, więc postanowiłem skonsolidować je w małym projekcie opakowania o nazwie CommonCryptoModule . Możesz zainstalować go ręcznie lub za pośrednictwem Cocoapods:

pod 'CommonCryptoModule', '~> 1.0.2'

Następnie wystarczy zaimportować moduł tam, gdzie jest potrzebny CommonCrypto, w następujący sposób:

import CommonCryptoModule

Mam nadzieję, że ktoś inny uzna to za przydatne.

Myślę, że poprawiłem doskonałą pracę Mike'a Wellera.

Dodaj fazę Run Script przed Compile Sourcesfazą zawierającą ten 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"

Ten skrypt konstruuje szkielet gołej kości z modułem module.map we właściwym miejscu, a następnie polega na automatycznym wyszukiwaniu BUILT_PRODUCTS_DIRramek przez Xcode .

Połączyłem oryginalny folder dołączania CommonCrypto jako folder nagłówków frameworka, więc wynik powinien również działać w projektach Celu C.

Dla każdego używającego swift 4.2 z Xcode 10 :

Moduł CommonCrypto jest teraz dostarczany przez system, więc możesz go zaimportować bezpośrednio, tak jak każdą inną strukturę systemu.

import CommonCrypto

@mogstad był na tyle miły, że umieścił rozwiązanie @stephencelis w Cocoapod:

pod „libCommonCrypto”

Inne dostępne kapsułki nie działały dla mnie.

Rozwiązania z modulemapami mogą być dobre i odporne na zmiany SDK, ale okazało się, że są one niewygodne w użyciu i nie są tak niezawodne, jak bym chciał, gdy przekazuję je innym. Aby uczynić to bardziej niezawodnym, poszedłem inną drogą:

Po prostu skopiuj nagłówki.

Wiem, kruche. Ale Apple prawie nigdy nie wprowadza znaczących zmian w CommonCrypto i żyję marzeniem, że nie zmienią go w żaden znaczący sposób bez ostatecznego przekształcenia CommonCrypto w modułowy nagłówek.

Przez „skopiuj nagłówki” mam na myśli „wytnij i wklej wszystkie potrzebne nagłówki do jednego ogromnego nagłówka w swoim projekcie, tak jak zrobiłby to preprocesor”. Jako przykład tego można skopiować lub dostosować, patrz RNCryptor.h .

Należy pamiętać, że wszystkie te pliki są objęte licencją APSL 2.0, a to podejście celowo utrzymuje prawa autorskie i uwagi dotyczące licencji. Mój krok konkatenacji jest licencjonowany na podstawie MIT, a dotyczy to tylko następnego zawiadomienia o licencji).

Nie twierdzę, że jest to piękne rozwiązanie, ale jak dotąd wydaje się, że było to niezwykle proste rozwiązanie zarówno dla wdrożenia, jak i wsparcia.

Wiem, że to stare pytanie. Ale wymyślam alternatywny sposób korzystania z biblioteki w projekcie Swift, który może być pomocny dla tych, którzy nie chcą importować frameworku przedstawionego w tych odpowiedziach.

W projekcie Swift utwórz nagłówek mostkujący Objective-C, stwórz kategorię NSData (lub klasę niestandardową, która ma korzystać z biblioteki) w Objective-C. Jedyną wadą byłoby to, że musisz napisać cały kod implementacji w Objective-C. Na przykład:

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

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

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

A następnie w nagłówku mostkowania celu c dodaj to

#import "NSData+NSDataEncryptionExtension.h"

A potem w klasie Swift wykonaj podobne rzeczy:

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

Działa zgodnie z oczekiwaniami.

Dodałem trochę magii cocoapods do odpowiedzi jjrscotta na wypadek, gdybyś musiał użyć CommonCrypto w swojej bibliotece cocoapods.

1) Dodaj tę linię do swojego podspec:

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

2) Zapisz to w folderze biblioteki lub gdziekolwiek chcesz (nie zapomnij jednak odpowiednio zmienić fazy skryptu ...)

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

Działa jak marzenie :)

Nie jestem pewien, czy coś się zmieniło w Xcode 9.2, ale teraz jest o wiele łatwiej to osiągnąć. Jedyne, co musiałem zrobić, to utworzyć folder o nazwie „CommonCrypto” w moim katalogu projektu frameworka i utworzyć w nim dwa pliki, jeden o nazwie „cc.h” w następujący sposób:

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

I kolejny o nazwie module.modulemap:

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

(Nie wiem, dlaczego nie można odwoływać się do plików nagłówkowych z obszaru SDKROOT bezpośrednio w pliku modulemap, ale nie mogłem go uruchomić)

Trzecią rzeczą jest znalezienie ustawienia „Importuj ścieżki” i ustawienie na $ (SRCROOT). W rzeczywistości możesz ustawić go na dowolny folder, w którym ma znajdować się folder CommonCrypto, jeśli nie chcesz go na poziomie głównym.

Po tym powinieneś być w stanie korzystać

import CommonCrypto

W dowolnym szybkim pliku i wszystkich typach / funkcjach / itp. są dostępne.

Słowo ostrzeżenia - jeśli Twoja aplikacja korzysta z libCommonCrypto (lub libcoreCrypto) wyjątkowo niezbyt wyrafinowanemu hakerowi wyjątkowo łatwo jest podłączyć debugera do Twojej aplikacji i dowiedzieć się, jakie klucze są przekazywane do tych funkcji.

Jeśli masz następujący problem:

ld: nie znaleziono biblioteki dla -lapple_crypto clang: error: komenda linkera nie powiodła się z kodem wyjścia 1 (użyj -v, aby zobaczyć wywołanie)

W Xcode 10, Swift 4.0. CommonCrypto jest częścią frameworka.

Dodaj

 import CommonCrypto

Usunąć

• Plik lib CommonCrpto z pliku binarnego łącza z bibliotekami z faz kompilacji
• import CommonCrypto z nagłówka Bridging

To zadziałało dla mnie!

Tak samo stało się ze mną po aktualizacji Xcode. Próbowałem wszystkiego, co mogłem zrobić, takich jak ponowna instalacja kokosów i czyszczenie projektu, ale to nie zadziałało. Teraz zostało rozwiązane po ponownym uruchomieniu systemu.

To jest bardzo proste. Dodaj

#import <CommonCrypto/CommonCrypto.h>

do pliku .h (mostkowy plik nagłówkowy twojego projektu). Jako konwencja możesz nazwać go YourProjectName-Bridging-Header.h.

Następnie przejdź do projektu Ustawienia budowania i poszukaj Swift Compiler - Generowanie kodu. Pod nim dodaj nazwę nagłówka pomostowego do wpisu „Objetive-C Bridging Header”.

Jesteś skończony. Nie wymaga importu w kodzie Swift. Wszelkie publiczne nagłówki Celu C wymienione w tym łączącym pliku nagłówkowym będą widoczne dla Swift.