Հնարավո՞ր է ինքնուրույն հոսթել Signal սերվերը
Signal-ը անվտանգ, բայց բարդ հաղորդակցման պլատֆորմ է։ Այս հոդվածում ուսումնասիրվում է, թե արդյոք Signal սերվերը կարելի է ինքնուրույն հոսթել տեղական մեքենայի վրա։
Signal-ը հիանալի մեսենջեր է, որը առաջին տեղում է դնում գաղտնիությունը և առաջարկում է end-to-end գաղտնագրում։ Ավելին, հավելվածը բաց կոդով է, ուստի կարող եք ստուգել և աուդիտի ենթարկել կոդը՝ և գուցե նույնիսկ ինքներդ աշխատեցնել այն։
Այս հոդվածում ուզում եմ պատմել Signal-ը իմ տեղական մեքենայի վրա աշխատեցնելու իմ փորձի մասին։
Սերվեր
Պաշտոնական signal repository-ն պարունակում է մի շարք բաղադրիչներ՝ սերվերը, android հավելվածը, libsignal-ը, contact discovery service-ը և այլն։
Թեև համակարգի ճշգրիտ ճարտարապետությունը պաշտոնապես փաստաթղթավորված չէ, AI-ի օգնությամբ ինձ հաջողվեց կազմել մի քանի բարձր մակարդակի ճարտարապետական ակնարկ։

Նշում. դիագրամը պարզեցված է և բաց է թողնում որոշ տարրեր։
Ակնհայտ է, որ բացարձակապես անհրաժեշտ միակ բաղադրիչը սերվերն է, ուստի հենց դրանից սկսեցի։ Repo-ում լավ փաստաթղթավորում չկա, բայց արժե նայել LocalWhisperServerService-ին։ Այս դասը, որը գտնվում է test scope-ում, թույլ է տալիս աշխատեցնել Signal Server-ի տեղական օրինակ, այն վերապահմամբ, որ որոշ տարբերակներ հասանելի չեն։ Այս թեստային սերվերը գործարկելու համար ես պարզապես աշխատեցրի այն իմ IDE-ից։
Այն նաև հղում է անում լռելյայն թեստային կոնֆիգին src/test/resources/config/test.yml և գաղտնիքներին src/test/resources/config/test-secrets-bundle.yml։ Այնտեղ կգտնեք սերվերի պահանջվող կախվածությունների մասին ավելի շատ մանրամասներ։ Բավական է մի հայացք՝ տեսնելու համար, որ դա այնքան պարզ չէ, որքան մի քանի կոնտեյներ բարձրացնելը, բայց գուցե կարող ենք փորձել բջջային հավելվածը միացնել LocalWhisperServerService-ին։
Բջջային հավելված
Ես բջջային հավելվածը վերցրի այս repository-ից և բացեցի Android Studio-ում՝ կոդը հարմար ուսումնասիրելու համար։
Շուրջը նայելիս հանդիպեցի app/build.gradle.kts-ին, որը պարունակում է տարբեր սերվիսների URL-ների հավաքածու։ SIGNAL_URL բանալիների տակ գտնվող յուրաքանչյուր URL-ը փոխարինեցի իմ համակարգչի IP հասցեով տնային ցանցում։
Այնուհետև գործարկեցի հավելվածը էմուլյատորում, և այն աշխատեց. մեծ հաջողություն։
Այնուամենայնիվ, թեև հավելվածը աշխատում էր, այն չէր կարողանում միանալ տեղականորեն աշխատող սերվերին։ Տեսնենք, թե ինչ կարող է լինել պատճառը։
Ելքային լոգերը ցույց էին տալիս սխալ, որ թույլատրվում են միայն TLS կապեր, ուստի սկսեցի ստանալ դոմեն և սերտիֆիկատ։ Հայտնաբերեցի մի «հնարք». կարելի է վավեր սերտիֆիկատ գեներացնել՝ գրանցելով duckdns ենթադոմեն և օգտագործելով Let's Encrypt։ Սերտիֆիկատն օգտագործելու համար ես տեղականորեն կոնտեյներում աշխատեցրի nginx-proxy-manager՝ LocalWhisperServerService-ի համար ճիշտ վերահասցեավորումներով։
Երկրորդ փորձ և… դեռ չի աշխատում… Թվում էր՝ սերտիֆիկատը գալիս է անվստահելի CA-ից, թեև բրաուզերը խնդիրներ չէր հայտնում։ Պարզվեց, որ բջջային հավելվածը պահում է իր սեփական trust store-ը, ուստի ես պետք է root CA-ն ավելացնեի app/src/main/res/raw/whisper.store-ում
Երրորդ փորձ և… հաջողություն. ինձ հաջողվեց «գրանցել» կեղծ հեռախոսահամար։
Առաջին քայլը CAPTCHA ստուգումն էր։ Երբ այն ճիշտ անցա, ստացա սխալ և ինձ ետ ուղարկեցին այն էկրան, որտեղ մուտքագրել էի հեռախոսահամարը։
Երբ նորից փորձեցի գրանցել համարը, հայտնվեցի այն էկրանին, որը պահանջում էր pass code։ Քանի որ որևէ SMS gateway չէի կարգավորել, և սա «TestServer» էր, մուտքագրեցի հեռախոսահամարի վերջին 6 թվանշանը։ Կոդը մուտքագրելուց հետո loader-ը շարունակում էր պտտվել, և մի քանի րոպե առանց արդյունքի հետո սեղմեցի Resend Code, ինչն օգնեց։ Հետագայում իմացա, որ ցանկացած կոդ ընդունվում է։
Հաջորդը պետք էր մուտքագրել անունս և ազգանունս։ Հետո պետք էր երկու անգամ տալ PIN համար իմ «հաշվի» համար։ Այդ քայլը ձախողվեց սխալի pop-up-ով, բայց ես դեռ կարողացա շարունակել և հասա գլխավոր էջ։
Գործարկենք երկրորդ հավելվածը և ստուգենք, թե կարո՞ղ ենք հաղորդագրություններ փոխանակել։ Հավելվածը բարձրանում է, բայց հայտնվում է մեկ այլ խոչընդոտ. մեկ այլ կոնտակտ գտնելը պահանջում է contact discovery service-ը։
Contact Discovery Service
Այս սերվիսը բարձրացնելը պարզ չէ։ Այն կախված է մի քանի բնիկ գրադարաններից, որոնք կոմպիլացվում են հատուկ x86 ճարտարապետության համար, ուստի MacOS-ի վրա աշխատեցնելը բացառվում է։
Պատճառն այն է, որ Signal-ը լրջորեն է վերաբերվում մեր գաղտնիությանը. contact discovery service-ը ապավինում է enclave-ների, որոնք թույլ չեն տալիս RAM-ին արտահոսեցնել ձեր տվյալները։ Դա արվում է գաղտնագրված և մշուշոտված RAM մուտքի օրինաչափություններով, որպեսզի վնասարար գործող անձինք չկարողանան «գուշակել» դրանք։ Signal-ի բլոգը սա լավ բացատրում է։
Գուցե կարո՞ղ է աշխատել կոնտեյներում։ Ցավոք, ոչ ամբողջությամբ։ Կրկին, սերվիսին անհրաժեշտ են բնիկ գրադարաններ, և դրանցից մեկը պետք է կոմպիլացվի, ինչը տեղի է ունենում… կոնտեյներում։
Բավականին շատ փորձերից հետո անցա Ubuntu աշխատեցնող VM-ի, և այնտեղ ինձ հաջողվեց այն աշխատեցնել։
Լավ, դա շատ ջանք էր պահանջում ընդամենը Contact Discovery Service-ը աշխատեցնելու համար. հիմա, անշուշտ, կարող եմ միանալ դրան։
Բջջային հավելվածի repository-ում թարմացրի Contact Discovery Service-ի URL-ները app/build.gradle.kts-ում (SIGNAL_CDSI_URL բանալիով կոնֆիգի դաշտերը)։ Գործարկեցի հավելվածը, բայց ընդհանրապես ելքային հարցումներ չտեսա, միայն սխալի լոգեր, որոնք ցույց էին տալիս, որ սերվիսին չի հաջողվում միանալ։
Ավելի խորանալով՝ հայտնաբերեցի, որ այս սերվիսին կապը կառավարվում է libsignal-ի կողմից. սա ընդհանուր արձանագրության գրադարան է։ Դա նաև նշանակում է, որ կապի URL-ը գտնվում է այնտեղ (app/build.gradle.kts-ում եղածները, կարծես, չեն օգտագործվում)։ Բարեբախտաբար, բջջային հավելվածը կարելի է կառուցել libsignal-ի տեղական պատճենի դեմ՝ gradle.properties ֆայլում libsignalClientPath և org.gradle.dependency.verification հատկությունները մեկնաբանությունից հանելով և սահմանելով։ libsignalClientPath-ը պետք է մատնացույց անի այն վայրը, որտեղ libsignal repository-ն գտնվում է մեքենայի վրա։
Թարմացրի DOMAIN_CONFIG_CDSI հատկությունների URL-ները libsignal repository-ի /rust/net/src/env.rs-ում, վերակառուցեցի բջջային հավելվածը, գործարկեցի այն և… կապը դեռ ձախողվում էր նույն սխալով։
Հենց այդ ժամանակ որոշեցի հրաժարվել փորձից, քանի որ սա միայն սառցաբեկորի գագաթն էր, և յուրաքանչյուր բաղադրիչը վրիպազերծելն ու հասկանալը շատ ժամանակ կպահանջեր
libsignal
Այսպես, հիմա գիտենք, որ Signal սերվերը ինքնուրույն հոսթելը շատ դժվար է (եթե ընդհանրապես հնարավոր է), բայց ինչ վիճակ է արձանագրության և ընդհանուր գրադարանի հետ։ Կարո՞ղ էի այս գրադարանի վրա գրել սեփական սերվերը։
Փորձեցի և կառուցեցի պարզ PoC սերվեր, որը ապավինում է libsignal-ին և MySql-ին՝ հաղորդագրությունները և սարքի տվյալները հետագա առբերման համար պահելու նպատակով։
Այն բաղկացած է երկու ենթանախագծից.
client-ը կոնսոլային հավելված է, որը հանդես է գալիս որպես արձանագրության կլիենտ՝ ընդունակ գաղտնագրել, վերծանել, ստանալ և ուղարկել հաղորդագրություններ։server-ը spring boot սերվեր է, որը պահում է բոլոր պահանջվող տեղեկությունները և հաղորդագրությունները, ինչը գործընթացը դարձնում է ասինխրոն։
client-ը և server-ը խոսում են միմյանց հետ HTTP-ով։
Երկուսն էլ աշխատեցնելու համար հետևեք նախագծի README.md-ի հրահանգներին
Սարքի գրանցում
Մինչ հաղորդագրությունները գաղտնագրելը և վերծանելը, նախ պետք է գեներացնենք՝
org.signal.libsignal.protocol.IdentityKeyPairorg.signal.libsignal.protocol.state.SignedPreKeyRecordorg.signal.libsignal.protocol.state.PreKeyRecord-ների ցանկ
Գեներացված տվյալները պետք է պահպանվեն հետագա օգտագործման համար org.signal.libsignal.protocol.state.SignalProtocolStore-ի իրականացման մեջ, որպեսզի ձեր «մանդատները» չկորչեն. սակայն պարզության համար ես ապավինեցի libsignal-ի հետ գալուն InMemory իրականացմանը և տվյալները պահեցի այնտեղ։ Արդյունքում հավելվածի յուրաքանչյուր գործարկում գեներացնում է թարմ մանդատներ։
Որպեսզի այլ օգտատերեր կարողանան մեզ հետ նիստ հաստատել, գրանցման ժամանակ սերվերին պետք է ուղարկվեն հետևյալ տվյալները՝
- IdentityKey (public)
- SignedPreKey (public) –
SignedPreKeyRecord-ի մաս - PreKeySignature –
SignedPreKeyRecord-ի մաս - PreKeys
Այս տվյալներով սերվերը հետագայում կարող է PreKeyBundle ուղարկել այն սարքին, որը խնդրում է այն։
Ստորև օրինակային repository-ից կոդի հատված է.
println("Enter your username:")
val username = readln()
val serverClient = ServerClient(serverURL = URI("http://localhost:8080"))
val identityKeyPair = IdentityKeyPair.generate()
val protocolStore = InMemorySignalProtocolStore(identityKeyPair, 2137)
val preKeys = generatePreKeys(1, 100)
preKeys.forEach { protocolStore.storePreKey(it.id, it) }
val signedPreKey = generateSignedPreKey(identityKeyPair, 0)
protocolStore.storeSignedPreKey(signedPreKey.id, signedPreKey)
val deviceDTO = serverClient.registerUser(username, identityKeyPair, signedPreKey, preKeys) ?: return
Նիստի հաստատում
Նիստ հաստատելու երկու եղանակ կա՝
- սերվերից
org.signal.libsignal.protocol.state.PreKeyBundleստանալով org.signal.libsignal.protocol.message.PreKeySignalMessageստանալով – սովորաբար մեկ այլ սարքից եկող առաջին հաղորդագրությունը։
Նախաձեռնողը նախ պետք է սերվերից ստանա ստացողի սարքին պատկանող PreKeyBundle-ը։ Հետո պետք է ստեղծի org.signal.libsignal.protocol.SessionBuilder և կանչի նրա process(PreKeyBundle) մեթոդը։ Այս քայլը պահում է բոլոր պահանջվող տեղեկությունները SignalProtocolStore-ում, որն ավելի ուշ օգտագործվում է հաղորդագրությունները գաղտնագրելու և վերծանելու համար։
Սա օրինակային repository-ի այն մասն է, որը դա մշակում է՝
val receiverInformation = getAndSaveUserInformation(serverClient, receiverName, otherUsers)
if (!protocolStore.containsSession(receiverInformation.toSignalProtocolAddress())) {
val userBundle = serverClient.getUserBundle(receiverName)
SessionBuilder(protocolStore, receiverInformation.toSignalProtocolAddress())
.process(userBundle.toPreKeyBundle(deviceDTO.deviceId))
}
Հաղորդագրությունների ուղարկում
Հաղորդագրություն ուղարկելը պահանջում է ստեղծել org.signal.libsignal.protocol.SessionCipher՝ նրան տալով SignalProtocolStore-ը և ստացողի SignalProtocolAddress-ը։
Նշում. Պարզության համար SignalProtocolAddress-ի համար անհրաժեշտ տվյալները գեներացվում են սերվերի կողմից և առբերվում ամեն անգամ, երբ անհրաժեշտ է։
Երբ SessionCipher-ը ունեք, պարզապես կանչում եք org.signal.libsignal.protocol.SessionCipher#encrypt(byte[]) մեթոդը։ Նրա վերադարձրած գաղտնագրված հաղորդագրությունը գնում է սերվեր, որտեղից մյուս սարքը կարող է վերցնել այն ավելի ուշ։
Օրինակ՝
val cipher = SessionCipher(protocolStore, receiverInformation.toSignalProtocolAddress())
val ciphertextMessage = cipher.encrypt(message.toByteArray())
serverClient.sendMessage(username, receiverName, ciphertextMessage)
Հաղորդագրությունների ստացում
Իր հաղորդագրությունները ստանալու համար սարքը կանչում է սերվերի endpoint, որը վերադարձնում է ամբողջ inbox-ը՝ ուղարկողի և հաղորդագրության տեսակի մանրամասներով։ Յուրաքանչյուր հաղորդագրություն կարելի է վերծանել միայն մեկ անգամ, և սերվերը ջնջում է այն բեռնվելուց հետո։
Հաղորդագրությունը վերծանելը պահանջում է ստեղծել (կամ առբերել) նրա ուղարկողի հետ կապված SessionCipher-ը։ Որպեսզի վերծանումը աշխատի, հաղորդագրությունը պետք է բերվի ճիշտ տիպի (cast)։
PreKeySignalMessageսարքի առաջին հաղորդագրության համարSignalMessageբոլոր մյուս հաղորդագրությունների համար
Տիպը որոշվում է messageType-ով, որը սերվերը պահում և վերադարձնում է։
Նշում. libsignal-ն առաջարկում է նաև այլ տեսակի հաղորդագրություններ, բայց պարզության համար ես կենտրոնացա ընդամենը 2-ի վրա։
PreKeySignalMessage-ի վերծանումը նիստ է հաստատում տվյալ սարքի հետ, ուստի սերվերից լրացուցիչ տվյալներ առբերելու կարիք չկա։
Դիտողություններ
Նկատի ունեցեք, որ libsignal-ը թողարկվում է AGPL-3.0 լիցենզիայով, ուստի այն օգտագործող ցանկացած ծրագրային ապահովում պետք է թողարկվի նույն լիցենզիայով։
Գրադարանը գերազանց է և թույլ է տալիս կառուցել end-to-end գաղտնագրմամբ ծրագրային ապահովում, բայց այն կառուցված է զուտ Signal էկոհամակարգի համար, և նրա տիպերն ու կառուցվածքները, կարծես, համապատասխանում են միայն այդ էկոհամակարգին։
Գրադարանի մեծ մասը գրված է rust-ով, ինչը վրիպազերծումը շատ դժվարացնում է, հատկապես Java / Kotlin կլիենտներում։
Ամփոփում
Signal-ը անվտանգ, բայց բարդ հաղորդակցման պլատֆորմ է։ Ամբողջ սերվիսը ինքնուրույն հոսթելը գրեթե անհնար է՝ հաշվի առնելով սակավ փաստաթղթավորումը, ստեկի բարդությունը և կարգավորման տարբերակները։ Սեփական սերվեր գրելը, մյուս կողմից, նույնպես ծանր աշխատանք է, նույնիսկ libsignal-ը ձեռքի տակ ունենալով։ Դա նշանակում է բաց կոդով թողարկել ձեր կոդը, լավ հասկանալ Signal Protocol-ը և զբաղվել բազմաթիվ եզրային դեպքերով, որոնց մասին ամենօրյա կյանքում չեք մտածում։