ISCC CTF Writeup : PHP in ASM

Diberikan sebuah file (bernama bytecode) dan sebuah string. Dideskripsi soal kita diharuskan mendekripsi string tersebut.

Stringnya adalah : UNbS0o4OTkzcmlpaTAwbWlrPjo8OD08Mz1pb2k4bj9qP2g/Oz5oPWltd

Dan dibawah merupakan isi dari file yang bernama bytecode.

compiled vars:  !0 = $flag, !1 = $tmp, !2 = $i
line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   6     0  E >   EXT_STMT                                                 
         1        ASSIGN                                                   !0, '<Redacted_Flag>'
   7     2        EXT_STMT                                                 
         3        INIT_FCALL                                               'gzdeflate'
         4        EXT_FCALL_BEGIN                                          
         5        SEND_VAR                                                 !0
         6        DO_FCALL                                      0  $4      
         7        EXT_FCALL_END                                            
         8        ASSIGN                                                   !1, $4
   9     9        EXT_STMT                                                 
        10        ASSIGN                                                   !2, 0
        11      > JMP                                                      ->95
  10    12    >   EXT_STMT                                                 
        13        MOD                                              ~7      !2, 2
        14        IS_IDENTICAL                                     ~8      ~7, 0
        15      > JMPZ                                                     ~8, ->47
  11    16    >   EXT_STMT                                                 
        17        INIT_FCALL                                               'chr'
        18        EXT_FCALL_BEGIN                                          
        19        INIT_FCALL                                               'ord'
        20        EXT_FCALL_BEGIN                                          
        21        FETCH_DIM_R                                      $10     !0, !2
        22        SEND_VAR                                                 $10
        23        DO_FCALL                                      0  $11     
        24        EXT_FCALL_END                                            
        25        BW_XOR                                           ~12     $11, 10
        26        SEND_VAL                                                 ~12
        27        DO_FCALL                                      0  $13     
        28        EXT_FCALL_END                                            
        29        ASSIGN_DIM                                               !0, !2
        30        OP_DATA                                                  $13
  12    31        EXT_STMT                                                 
        32        INIT_FCALL                                               'chr'
        33        EXT_FCALL_BEGIN                                          
        34        INIT_FCALL                                               'ord'
        35        EXT_FCALL_BEGIN                                          
        36        FETCH_DIM_R                                      $15     !0, !2
        37        SEND_VAR                                                 $15
        38        DO_FCALL                                      0  $16     
        39        EXT_FCALL_END                                            
        40        BW_XOR                                           ~17     $16, 2
        41        SEND_VAL                                                 ~17
        42        DO_FCALL                                      0  $18     
        43        EXT_FCALL_END                                            
        44        ASSIGN_DIM                                               !0, !2
        45        OP_DATA                                                  $18
        46      > JMP                                                      ->77
  14    47    >   EXT_STMT                                                 
        48        INIT_FCALL                                               'chr'
        49        EXT_FCALL_BEGIN                                          
        50        INIT_FCALL                                               'ord'
        51        EXT_FCALL_BEGIN                                          
        52        FETCH_DIM_R                                      $20     !0, !2
        53        SEND_VAR                                                 $20
        54        DO_FCALL                                      0  $21     
        55        EXT_FCALL_END                                            
        56        BW_XOR                                           ~22     $21, 11
        57        SEND_VAL                                                 ~22
        58        DO_FCALL                                      0  $23     
        59        EXT_FCALL_END                                            
        60        ASSIGN_DIM                                               !0, !2
        61        OP_DATA                                                  $23
  15    62        EXT_STMT                                                 
        63        INIT_FCALL                                               'chr'
        64        EXT_FCALL_BEGIN                                          
        65        INIT_FCALL                                               'ord'
        66        EXT_FCALL_BEGIN                                          
        67        FETCH_DIM_R                                      $25     !0, !2
        68        SEND_VAR                                                 $25
        69        DO_FCALL                                      0  $26     
        70        EXT_FCALL_END                                            
        71        BW_XOR                                           ~27     $26, 3
        72        SEND_VAL                                                 ~27
        73        DO_FCALL                                      0  $28     
        74        EXT_FCALL_END                                            
        75        ASSIGN_DIM                                               !0, !2
        76        OP_DATA                                                  $28
  17    77    >   EXT_STMT                                                 
        78        INIT_FCALL                                               'chr'
        79        EXT_FCALL_BEGIN                                          
        80        INIT_FCALL                                               'ord'
        81        EXT_FCALL_BEGIN                                          
        82        FETCH_DIM_R                                      $30     !0, !2
        83        SEND_VAR                                                 $30
        84        DO_FCALL                                      0  $31     
        85        EXT_FCALL_END                                            
        86        SL                                               ~32     $31, 22
        87        MOD                                              ~33     ~32, 255
        88        SEND_VAL                                                 ~33
        89        DO_FCALL                                      0  $34     
        90        EXT_FCALL_END                                            
        91        ASSIGN_DIM                                               !0, !2
        92        OP_DATA                                                  $34
   9    93        POST_INC                                         ~35     !2
        94        FREE                                                     ~35
        95    >   STRLEN                                           ~36     !0
        96        IS_SMALLER                                       ~37     !2, ~36
        97        EXT_STMT                                                 
        98      > JMPNZ                                                    ~37, ->12
  22    99    >   EXT_STMT                                                 
       100        INIT_FCALL                                               'base64_encode'
       101        EXT_FCALL_BEGIN                                          
       102        SEND_VAR                                                 !0
       103        DO_FCALL                                      0  $38     
       104        EXT_FCALL_END                                            
       105        CONCAT                                           ~39     $38, '%0A'
       106        ECHO                                                     ~39
  25   107      > RETURN                                                   1

Saya belum pernah melihat instruksi-instruksi tersebut sebelumnya, tetapi karena judul challenge yg mereferensikan PHP, jadi saya mensearch di google “php opcode” dan menemukan halaman ini https://www.php.net/manual/en/internals2.opcodes.php dan https://phpinternals.net/categories/opcodes.

Setelah memahami instruksi-instruksi diatas, sekarang kita akan mendecompile manual instruksi-instruksi secara bertahap menjadi code yang lebih mudah dibaca.

Diawal, terdapat instruksi ini.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   6     0  E >   EXT_STMT                                                 
         1        ASSIGN                                                   !0, '<Redacted_Flag>'

Untuk instruksi EXT_STMT saya belum menemukan penjelasannya di internet, tapi saya kira instruksi tersebut menandakan awal statement di php.

Instruksi ASSIGN op1, op2 akan menyimpan op2 yang berupa value ke dalam op1 yang berupa variable. Jadi instruksi ASSIGN !0, '<Redacted_Flag>' akan menyimpan '<Redacted_Flag>' ke variable !0. <Redacted_Flag>' adalah string yang flag yg hilang yang harus kita cari. Instruksi diatas dapat diterjemahkan menjadi.

!0 = '<Redacted_Flag>'

Selanjutnya terdapat instruksi-instruksi seperti ini.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
.....
   7     2        EXT_STMT                                                 
         3        INIT_FCALL                                               'gzdeflate'
         4        EXT_FCALL_BEGIN                                          
         5        SEND_VAR                                                 !0
         6        DO_FCALL                                      0  $4      
         7        EXT_FCALL_END

Ada instruksi EXT_STMT yang digunakan untuk mengawali statement baru. Instruksi INIT_FCALL dengan operandnya yaitu gzdefalte akan mempersiapkan pemanggilan fungsi ke gzdefalte.

EXT_FCALL_BEGIN saya belum menemukan penjelasannya di manual PHP, tapi saya kira ini merupakan sebagai penanda bahwa sebuah fungsi akan dipanggil (mohon dikoreksi).

Instruksi SEND_VAR memiliki operand yang akan dikirim sebagai parameter ke fungsi yang ingin dipanggil, operand pada instruksi diatas adalah !0.

Instruksi DO_FCALL akan memanggil fungsi yang sebelumnya telah disiapkan yaitu gzdeflate. Terdapat juga properti return value pada tabel diatas yang berisi $4, itu artinya return value atau hasil pemanggilan fungsi tersebut akan disimpan di variable $4.

Sementara EXT_FCALL_END saya kira itu sebagai opposite dari EXT_FCALL_BEGIN.

Jadi instruksi diatas jika diterjemahkan ke dalam kode sederhana menjadi.

$4 = gzdeflate(!0)

Dibawahnya lagi terdapat instruksi :

         8        ASSIGN                                                   !1, $4

Instruksi diatas akan mengisi variable !1 dengan $4 (!1 = $4). Jika kita gabungkan dengan hasil dekompilasi sebelumnya, maka hasilnya akan menjadi.

!1 = gzdeflate(!0)

Setelah itu terdapati instruksi :

   9     9        EXT_STMT                                                 
        10        ASSIGN                                                   !2, 0

Instruksi diatas akan mengisi variable !2 dengan 0.

!2 = 0

Setelah itu terdapat instruksi JMP yang akan loncat ke instruksi ke 95.

        11      > JMP                                                      ->95

Ketika eksekusi diatas loncat ke instruksi ke 95, program akan mengeksekusi instruksi ini.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
...
        95    >   STRLEN                                           ~36     !0
        96        IS_SMALLER                                       ~37     !2, ~36
        97        EXT_STMT                                                 
        98      > JMPNZ                                                    ~37, ->12

Terdapat instruksi STRLEN yang memiliki operand !0. Instruksi diatas akan menghasilkan panjang string yg dimiliki oleh !0 dan menyimpannya di variable ~36.

Setelah itu terdapat instruksi IS_SMALLER yang melakukan perbandingan dua buah operand, yaitu !2 dan ~36. Dari informasi diatas return valuenya akan disimpan di variable ~37. Jika operand pertama lebih kecil dari operand kedua, maka akan menghasilkan 1 (true) jika tidak 0 (false).

Setelah itu ada intruksi EXT_SMT, karena ini kurang berguna untuk dijelaskan, jadi dibawah tidak usah saya mention lagi.

Instruksi JMPNZ yang memiliki operand ~37 dan ->12 akan mengubah ekseskusi program ke instruksi 12, jika variable ~37 bukan sama dengan nol.

Dari hasil analisa diatas, kita dapat mengubah ke dalam kode sederhana menjadi.

do {
...
} while(!2 < strlen(!0))

Setelah itu kita liat instruksi ke 12, karena program akan loncat ke instruksi ini.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
...
  10    12    >   EXT_STMT                                                 
        13        MOD                                              ~7      !2, 2
        14        IS_IDENTICAL                                     ~8      ~7, 0
        15      > JMPZ                                                     ~8, ->47

Terdapat instruksi MOD dengan operand !2 dan 2, instruksi ini akan melakukan operasi modulus pada variable !2 dengan nilai 2, sesuai informasi, hasil dari operasi tersebut akan disimpan di ~7.

Selanjutnya instruksi IS_IDENTICAL akan melakukan perbandingan dua operand, jika sama menghasilkan nilai 1 (true) jika tidak 0 (false).

Instruksi JMPZ ~8, ->47 akan melakukan lompatan ke instruksi 47, jika variable ~8 berisi nol. Jika tidak eksekusi akan lanjut ke instruksi setelahnya (instruksi ke 16).

Hasil analisa diatas dapat disimpulkan ke dalam kode yg mudah dibaca, kira-kira hasilnya seperti ini.

if (!2 % 2) {
    ...
}
...

Sebelum kita ke instruksi 47, kita lanjut ke instruksi ke 16, instruksi ini akan masuk kedalam blok IF.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  11    16    >   EXT_STMT                                                 
        17        INIT_FCALL                                               'chr'
        18        EXT_FCALL_BEGIN                                          
        19        INIT_FCALL                                               'ord'
        20        EXT_FCALL_BEGIN                                          
        21        FETCH_DIM_R                                      $10     !0, !2
        22        SEND_VAR                                                 $10
        23        DO_FCALL                                      0  $11     
        24        EXT_FCALL_END                                            
        25        BW_XOR                                           ~12     $11, 10
        26        SEND_VAL                                                 ~12
        27        DO_FCALL                                      0  $13     
        28        EXT_FCALL_END                                            
        29        ASSIGN_DIM                                               !0, !2
        30        OP_DATA                                                  $13

Dari instruksi ke 16 sampai 19, instruksi akan menyiapkan pemanggilan fungsi chr dan ord.

Setelah itu instruksi FETCH_DIM_R akan mengambil elemen array yg ditunjuk pada operand pertama dengan index yg ditunjuk pada operand kedua. Return value instruksi diatas sesusai informasi akan disimpan di variable $10.

Selanjutnya insruksi SEND_VAL yg memiliki operand $10 akan menjadikan variable tersebut sebagai parameter untuk pemanggilan fungsi selanjutnya.

Instruksi DO_FCALL akan memanggil fungsi yang dipersiapkan INIT_FCALL sebelumnya yakni fungsi ord. Return valuenya akan disimpan di variable $11.

Instruksi EXT_FCALL_END menandakan selesainya pemanggilan ord. sekarang, pemanggilan yg dipersiapkan selanjutnya ialah fungsi chr (lihat lagi instruksi ke 16 sampai 19).

Setelah itu terdapat instruksi BW_XOR yang melakukan operasi xor terhadap dua operand, hasil dari instruksi tersebut akan disimpan di variable ~12.

Instruksi SEND_VAL dengan operand ~12 akan menyiapkan variable tersebut untuk dijadikan sebagai parameter pada pemanggilan selanjutnya.

Selanjutnya instruksi DO_FCALL akan memanggil fungsi chr (fungsi yang sebelumnya disiapkan pada instruksi ke 17). Return value dari pemanggilan fungsi tersebut akan disimpan pada variable $13.

Kita skip instruksi EXT_FCALL_END. Setelah itu terdapat dua buah instruksi.

        29        ASSIGN_DIM                                               !0, !2
        30        OP_DATA                                                  $13

Singkatnya, kedua instruksi diatas akan mengisi nilai pada variable !0 pada index !2 dengan nilai yg ditunjuk oleh variable $13.

!0[!2] = $13

Dari hasil analisa diatas, kita dapat menerjemahkan ke dalam kode yang mudah dibaca menjadi.

$10 = !0[!2]
$11 = ord($10)
$13 = chr($11 ^ 10)
!0[!2] = $13

Atau jika diringkas menjadi.

!0[!2] = chr(ord(!0[!2]) ^ 10)

Lanjut ke analisa instruksi berikutnya, yakni.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
...
  12    31        EXT_STMT                                                 
        32        INIT_FCALL                                               'chr'
        33        EXT_FCALL_BEGIN                                          
        34        INIT_FCALL                                               'ord'
        35        EXT_FCALL_BEGIN                                          
        36        FETCH_DIM_R                                      $15     !0, !2
        37        SEND_VAR                                                 $15
        38        DO_FCALL                                      0  $16     
        39        EXT_FCALL_END                                            
        40        BW_XOR                                           ~17     $16, 2
        41        SEND_VAL                                                 ~17
        42        DO_FCALL                                      0  $18     
        43        EXT_FCALL_END                                            
        44        ASSIGN_DIM                                               !0, !2
        45        OP_DATA                                                  $18

Jika diperhatikan instruksi-instruksi diatas memiliki pola yang hampir mirip, hanya saja nilai pada saat operasi xornya saja yang berbeda (lihat pada instruksi ke 40, operasi xor memiliki angka 2 pada operandnya). Hasil dari terjemahan instruksi diatas ke dalam kode yang mudah dibaca menjadi.

!0[!2] = chr(ord(!0[!2]) ^ 2)

Setelah itu terdapat instruksi JMP.

        46      > JMP                                                      ->77

Nampaknya Blok IF yang kita analisa sebelumnya telah selesai. Masih ingat sebelumnya? kita harus menganalisa instruksi ke 47 terlebih dahulu sebelum menganalisa instruksi ke 77.

Bisa kita simpulkan juga, instruksi ke 47 merupakan blok ELSEnya, karena perbandingan dengan kondisi pada awal blok if ketika false akan loncat ke instruksi 47 dan ketika blok IF berakhir eksekusi akan melakukan jump ke instruksi 77.

Struktur programnya kira2 seperti ini.

do {
    if ( ... ) {
        ...          // instruction start at 31
    } else {
        ...          // instruction start at 47
    }
    ...              // instruction start at 77
} while( ... )

Oke, selanjutnya pada instruksi ke 47 terdapat kode seperti ini.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
...
        48        INIT_FCALL                                               'chr'
        49        EXT_FCALL_BEGIN                                          
        50        INIT_FCALL                                               'ord'
        51        EXT_FCALL_BEGIN                                          
        52        FETCH_DIM_R                                      $20     !0, !2
        53        SEND_VAR                                                 $20
        54        DO_FCALL                                      0  $21     
        55        EXT_FCALL_END                                            
        56        BW_XOR                                           ~22     $21, 11
        57        SEND_VAL                                                 ~22
        58        DO_FCALL                                      0  $23     
        59        EXT_FCALL_END                                            
        60        ASSIGN_DIM                                               !0, !2
        61        OP_DATA                                                  $23
  15    62        EXT_STMT                                                 
        63        INIT_FCALL                                               'chr'
        64        EXT_FCALL_BEGIN                                          
        65        INIT_FCALL                                               'ord'
        66        EXT_FCALL_BEGIN                                          
        67        FETCH_DIM_R                                      $25     !0, !2
        68        SEND_VAR                                                 $25
        69        DO_FCALL                                      0  $26     
        70        EXT_FCALL_END                                            
        71        BW_XOR                                           ~27     $26, 3
        72        SEND_VAL                                                 ~27
        73        DO_FCALL                                      0  $28     
        74        EXT_FCALL_END                                            
        75        ASSIGN_DIM                                               !0, !2
        76        OP_DATA                                                  $28

Polanya sama seperti instruksi yang ada didalam blok if, tinggal mengganti value yang dixornya saja. Hasil terjemahan blok else ini ke dalam kode yang mudah dibaca menjadi.

!0[!2] = chr(ord(!0[!2]) ^ 11)
!0[!2] = chr(ord(!0[!2]) ^ 3)

Blok IF-ELSE sudah berakhir. Selanjutnya pada instruksi ke 77 terdapat instruksi.

line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
...
  17    77    >   EXT_STMT                                                 
        78        INIT_FCALL                                               'chr'
        79        EXT_FCALL_BEGIN                                          
        80        INIT_FCALL                                               'ord'
        81        EXT_FCALL_BEGIN                                          
        82        FETCH_DIM_R                                      $30     !0, !2
        83        SEND_VAR                                                 $30
        84        DO_FCALL                                      0  $31     
        85        EXT_FCALL_END                                            
        86        SL                                               ~32     $31, 22
        87        MOD                                              ~33     ~32, 255
        88        SEND_VAL                                                 ~33
        89        DO_FCALL                                      0  $34     
        90        EXT_FCALL_END                                            
        91        ASSIGN_DIM                                               !0, !2
        92        OP_DATA                                                  $34
   9    93        POST_INC                                         ~35     !2
        94        FREE                                                     ~35

Pada instruksi ke 78 sampai 81 terdapat instruksi2 yang digunakan untuk menyiapkan pemanggilan fungsi chr dan ord.

Selanjutnya terdapat instruksi FETCH_DIM_R dengan operand !0 dan !2 yang akan mengambil nilai pada variable !0 dengan index !2, hasilnya akan disimpan di variable $30.

Instruksi SEND_VAR akan mengirim variable $30 sebagai parameter untuk pemanggilan fungsi, dilanjutkan instruksi DO_FCALL yang melakukan pemanggilan fungsi ord, return value akan disimpan pada variable $31.

Setelah itu terdapat instruksi SL yang merupakan operasi shift left (<<), instruksi diatas akan melakukan operasi pada variable $31 yg melakukan shift left dengan nilai 22. Hasil dari operasi tersebut akan disimpan pada variable ~32.

Selanjutnya instruksi MOD dengan operand ~32 dan 255, akan melakukan operasi modulus yang hasilnya akan disimpan pad variable ~33.

Instruksi SEND_VAR akan menyiapkan parameter untuk pemanggilan fungsi selanjutnya, yakni variable ~33 yang akan dijadikan parameter.

Instruksi DO_FCALL akan memanggil fungsi chr yang sebelumnya telah disiapkan. Hasilnya akan disimpan pada variable $34.

Setelah itu terdapat instruksi ASSIGN_DIM dan OP_DATA yang mengisi variable !0 pada index !2 dengan nilai yg dimiliki oleh variable $34.

Dan, instruksi POST_INC akan menincrement variable !2.

Sepertinya instruksi FREE setelahnya bisa kita skip karena kurang berguna untuk analisa.

Hasil dari analisa diatas dapat kita simpulkan ke dalam kode yang lebih mudah dibaca menjadi.

$30 = !0[!2]
$31 = ord($30)
$34 = chr(($31 << 22) % 255)
!0[!2] = $34
!2++

Atau dapat kita ringkas menjadi.

!0[!2] = chr((ord(!0[!2]) << 2) % 255)

Selanjutnya terdapat instruksi.

        95    >   STRLEN                                           ~36     !0
        96        IS_SMALLER                                       ~37     !2, ~36
        97        EXT_STMT                                                 
        98      > JMPNZ                                                    ~37, ->12

Instruksi-instruksi diatas sudah kita analisa sebelumnya yang merupakan perbandingan yg digunakan dalam blok WHILE. Ini tandanya blok WHILE sudah berakhir. Kita lanjut ke instruksi berikutnya.

       100        INIT_FCALL                                               'base64_encode'
       101        EXT_FCALL_BEGIN                                          
       102        SEND_VAR                                                 !0
       103        DO_FCALL                                      0  $38     
       104        EXT_FCALL_END                                            
       105        CONCAT                                           ~39     $38, '%0A'
       106        ECHO                                                     ~39
  25   107      > RETURN                                                   1

Singkatnya instruksi diatas akan memanggil fungsi base64_encode dengan parameter !0 dan hasilnya akan di echo.

echo(base64encode(!0))

Satukan hasil dari kode2 yang telah dianalia, yang akan menjadi kode dibawah ini.

!0 = '<Redacted_Flag>'
!1 = gzdeflate(!0)
!2 = 0
do {
    if (!2 % 2) {
        !0[!2] = chr(ord(!0[!2]) ^ 10)
        !0[!2] = chr(ord(!0[!2]) ^ 2)
    } else {
        !0[!2] = chr(ord(!0[!2]) ^ 11)
        !0[!2] = chr(ord(!0[!2]) ^ 3)
    }
    !0[!2] = chr((ord(!0[!2]) << 2) % 255)
} while (!2 < strlen(!0))
echo(base64_encode(!0))

Hasilnya lebih mudah dibaca bukan?. Tinggal kita mereverse algoritma diatas untuk mendapatkan flag. Saya menggunakan script python dengan z3 untuk mempermudah.

from base64 import *
from z3 import *
b = b64decode("UNbS0o4OTkzcmlpaTAwbWlrPjo8OD08Mz1pb2k4bj9qP2g/Oz5oPWltd")
flag = [BitVec("flag{}".format(i), 32) for i in range(42)]
s = Solver()
for i in range(len(b)):
    if i % 2:
            s.add(((flag[i] ^ 10 ^ 2) << 22) % 255 == ord(b[i]))
    else:
            s.add(((flag[i] ^ 11 ^ 3) << 22) % 255 == ord(b[i]))
    s.add(flag[i] > 0, flag[i] < 255)

s.check()
m = s.model()
hasil = ""
for f in flag:
    hasil += chr(m[f].as_long())
print("Flag: {}".format(hasil))

Jalankan script diatas, dan flag didapatkan.

Flag: ISCC2019{baa98daa72604587aec1d6c6c437b4ae}

Jika kalian terbiasa membaca hasil disassembly dari bytecode atau bahasa mesin, analisa diatas akan jauh lebih cepat dan terasa mudah.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s