Rust: update docs #19280

redsun82 · 2025-04-11T05:55:54Z

This should be kept unmerged until we get to the public preview phase.

geoffw0

A few more libraries we model (partial support, but then I don't think we can claim to fully model any libraries). Sorry I probably missed a few of these in the list I sent you before.

We also have models for the standard io library coming in #19304 , I should update that PR once this is merged or vice-versa.

docs/codeql/reusables/supported-frameworks.rst

Co-authored-by: Geoffrey White <[email protected]>

rust/ql/lib/codeql/rust/elements/Callable.qll

rust/ql/lib/codeql/rust/elements/internal/generated/CallExprBase.qll

rust/ql/lib/codeql/rust/elements/internal/generated/Callable.qll

…rtcuts" This reverts commit c70decb.

This reverts commit 9c2fea9.

This reverts commit f647b33.

geoffw0

The two docs + other changes look great to me!

Some minor suggestions below.

"CodeQL library for Rust" doesn't go into a lot of detail, I think that's OK at this stage, it would be nice to have more example code in future.

I haven't checked the links, references to notes, and generally that everything fits together correctly - we really need a full preview for that and/or to be ready to correct any problems quickly after this goes live.

You should probably get a review from the docs team next?

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

geoffw0 · 2025-06-16T16:28:59Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+        exists(Function f, CallExpr call, int index |
+        call.getArg(index) = node.asExpr().getExpr() and
+        call.getStaticTarget() = f and
+        f.getParam(index).getPat().(IdentPat).getName().getText() = "password"


We should strongly consider adding helper predicates getParamName and getArgName to make code like this a bit cleaner?

Good idea! I already cleaned up getting by index (it was f.getParamList().getParam(index)), but a getParamByName seems a good addition too!

Yep, I noticed that. 👍

docs/codeql/codeql-language-guides/codeql-for-rust.rst

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

geoffw0 · 2025-06-16T16:39:48Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+Data flow is particularly useful for security queries, where untrusted data flows to vulnerable parts of the program
+to exploit it. Related to data flow, is the taint-tracking library, which finds how data can *influence* other values


I'm not clear what "it" is, and I think these few words are superfluous anyway.

Suggested change

Data flow is particularly useful for security queries, where untrusted data flows to vulnerable parts of the program

to exploit it. Related to data flow, is the taint-tracking library, which finds how data can *influence* other values

Data flow is particularly useful for security queries, where untrusted data flows to vulnerable parts of the program. Related to data flow is the taint-tracking library, which finds how data can *influence* other values

This hasn't been addressed yet.

I was sure I did, sorry!

geoffw0 · 2025-06-16T16:43:28Z

docs/codeql/query-help/rust-cwe.md

+
+## Overview
+
+<!-- autogenerated CWE coverage table will be added below -->


I'm appreciative of the automation here!

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

hvitved · 2025-06-17T08:19:47Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+      ...
+     }
+
+You can use the predicates ``exprNode`` and ``parameterNode`` to map from expressions and parameters to their data-flow node:


I actually don't think those predicates exist yet.

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

sunbrye

Reviewing on behalf of the docs team. I've added editorial suggestions, but aside from that, this looks good to me ✅

sunbrye · 2025-06-19T16:48:07Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+Local data flow
+---------------
+
+Local data flow tracks the flow of data within a single method or callable. Local data flow is easier, faster, and more precise than global data flow. Before looking at more complex tracking, you should always consider local tracking because it is sufficient for many queries.


Suggested change

Local data flow tracks the flow of data within a single method or callable. Local data flow is easier, faster, and more precise than global data flow. Before looking at more complex tracking, you should always consider local tracking because it is sufficient for many queries.

Local data flow tracks the flow of data within a single method or callable. Local data flow is easier, faster, and more precise than global data flow. Before using more complex tracking, consider local tracking, as it is sufficient for many queries.

sunbrye · 2025-06-19T16:50:16Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+      ...
+    }
+
+


Styling NIT: Remove the extra new line here.

Please feel free to ignore this comment if it should stay as is

sunbrye · 2025-06-19T16:53:54Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+Note that since ``asExpr`` maps from data-flow to control-flow nodes, you then need to call the ``getExpr`` member predicate on the control-flow node to map to the corresponding AST node,
+for example by writing ``node.asExpr().getExpr()``.


Suggested change

Note that since ``asExpr`` maps from data-flow to control-flow nodes, you then need to call the ``getExpr`` member predicate on the control-flow node to map to the corresponding AST node,

for example by writing ``node.asExpr().getExpr()``.

Note that because ``asExpr`` maps from data-flow to control-flow nodes, you need to call the ``getExpr`` member predicate on the control-flow node to map to the corresponding AST node. For example, you can write ``node.asExpr().getExpr()``.

sunbrye · 2025-06-19T16:58:15Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+A control-flow graph considers every way control can flow through code, consequently, there can be multiple data-flow and control-flow nodes associated with a single expression node in the AST.
+
+The predicate ``localFlowStep(Node nodeFrom, Node nodeTo)`` holds if there is an immediate data flow edge from the node ``nodeFrom`` to the node ``nodeTo``.
+You can apply the predicate recursively, by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localFlow``.


Suggested change

You can apply the predicate recursively, by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localFlow``.

You can apply the predicate recursively by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localFlow``.

sunbrye · 2025-06-19T16:59:51Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+
+The local taint tracking library is in the module ``TaintTracking``.
+Like local data flow, a predicate ``localTaintStep(DataFlow::Node nodeFrom, DataFlow::Node nodeTo)`` holds if there is an immediate taint propagation edge from the node ``nodeFrom`` to the node ``nodeTo``.
+You can apply the predicate recursively, by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localTaint``.


Suggested change

You can apply the predicate recursively, by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localTaint``.

You can apply the predicate recursively by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localTaint``.

sunbrye · 2025-06-19T17:02:10Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+Using local sources
+~~~~~~~~~~~~~~~~~~~
+
+When exploring local data flow or taint propagation between two expressions as above, you would normally constrain the expressions to be relevant to your investigation.


Suggested change

When exploring local data flow or taint propagation between two expressions as above, you would normally constrain the expressions to be relevant to your investigation.

When exploring local data flow or taint propagation between two expressions, such as in the previous example, you typically constrain the expressions to those relevant to your investigation.

sunbrye · 2025-06-19T17:15:23Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+The next section gives some concrete examples, but first it's helpful to introduce the concept of a local source.
+
+A local source is a data-flow node with no local data flow into it.
+As such, it is a local origin of data flow, a place where a new value is created.
+This includes parameters (which only receive values from global data flow) and most expressions (because they are not value-preserving).
+The class ``LocalSourceNode`` represents data-flow nodes that are also local sources.
+It comes with a useful member predicate ``flowsTo(DataFlow::Node node)``, which holds if there is local data flow from the local source to ``node``.


Suggested change

The next section gives some concrete examples, but first it's helpful to introduce the concept of a local source.

A local source is a data-flow node with no local data flow into it.

As such, it is a local origin of data flow, a place where a new value is created.

This includes parameters (which only receive values from global data flow) and most expressions (because they are not value-preserving).

The class ``LocalSourceNode`` represents data-flow nodes that are also local sources.

It comes with a useful member predicate ``flowsTo(DataFlow::Node node)``, which holds if there is local data flow from the local source to ``node``.

The next section provides concrete examples, but first introduces the concept of a local source.

A local source is a data-flow node with no local data flow into it.

It is a local origin of data flow, a place where a new value is created.

This includes parameters (which only receive values from global data flow) and most expressions (because they are not value-preserving).

The class ``LocalSourceNode`` represents data-flow nodes that are also local sources.

It includes a useful member predicate ``flowsTo(DataFlow::Node node)``, which holds if there is local data flow from the local source to ``node``.

sunbrye · 2025-06-19T17:16:21Z

docs/codeql/codeql-language-guides/codeql-for-rust.rst

+   codeql-library-for-rust
+   analyzing-data-flow-in-rust
+
+-  :doc:`CodeQL library for Rust <codeql-library-for-rust>`: When you're analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.


Suggested change

- :doc:`CodeQL library for Rust <codeql-library-for-rust>`: When you're analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.

- :doc:`CodeQL library for Rust <codeql-library-for-rust>`: When analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.

sunbrye · 2025-06-19T17:16:45Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+CodeQL library for Rust
+=================================
+
+When you're analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.


Suggested change

When you're analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.

When analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.

sunbrye · 2025-06-19T17:19:53Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+Unfortunately this will only give the expression in the argument, not the values which could be passed to it.
+So we use local data flow to find all expressions that flow into the argument:


Suggested change

Unfortunately this will only give the expression in the argument, not the values which could be passed to it.

So we use local data flow to find all expressions that flow into the argument:

Unfortunately, this only returns the expression used as the argument, not the possible values that could be passed to it. To address this, you can use local data flow to find all expressions that flow into the argument.

sunbrye · 2025-06-19T17:23:31Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+      DataFlow::localFlow(source, sink)
+    select source, sink
+
+We can vary the source, for example, making the source the parameter of a function rather than an expression. The following query finds where a parameter is used for the file creation:


Suggested change

We can vary the source, for example, making the source the parameter of a function rather than an expression. The following query finds where a parameter is used for the file creation:

You can vary the source by making the source the parameter of a function instead of an expression. The following query finds where a parameter is used in file creation:

sunbrye · 2025-06-19T17:26:34Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+Global taint tracking is to global data flow what local taint tracking is to local data flow.
+That is, global taint tracking extends global data flow with additional non-value-preserving steps.
+The global taint tracking library uses the same configuration module as the global data flow library. You can perform taint flow analysis using ``TaintTracking::Global``:


Suggested change

Global taint tracking is to global data flow what local taint tracking is to local data flow.

That is, global taint tracking extends global data flow with additional non-value-preserving steps.

The global taint tracking library uses the same configuration module as the global data flow library. You can perform taint flow analysis using ``TaintTracking::Global``:

Global taint tracking relates to global data flow in the same way that local taint tracking relates to local data flow.

In other words, global taint tracking extends global data flow with additional non-value-preserving steps.

The global taint tracking library uses the same configuration module as the global data flow library. You can perform taint flow analysis using ``TaintTracking::Global``:

sunbrye · 2025-06-19T17:28:59Z

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst

+  - Since this is a taint-tracking query, the ``TaintTracking::Global`` module is used.
+  - The ``isSource`` predicate defines sources as any ``StringLiteralExpr``.
+  - The ``isSink`` predicate defines sinks as arguments to a ``CallExpr`` called "password".
+  - The sources and sinks may need tuning to a particular use, for example, if passwords are represented by a type other than ``String`` or passed in arguments of a different name than "password".


Suggested change

- The sources and sinks may need tuning to a particular use, for example, if passwords are represented by a type other than ``String`` or passed in arguments of a different name than "password".

- The sources and sinks may need to be adjusted for a particular use. For example, passwords might be represented by a type other than ``String`` or passed in arguments with a different name than "password".

sunbrye · 2025-06-19T17:31:49Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+CodeQL ships with a library for analyzing Rust code. The classes in this library present the data from a CodeQL database in an object-oriented form and provide
+abstractions and predicates to help you with common analysis tasks.
+
+The library is implemented as a set of CodeQL modules, that is, files with the extension ``.qll``. The


Suggested change

The library is implemented as a set of CodeQL modules, that is, files with the extension ``.qll``. The

The library is implemented as a set of CodeQL modules, which are files with the extension ``.qll``. The

sunbrye · 2025-06-19T17:32:34Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+   import rust
+
+The CodeQL libraries model various aspects of Rust code. The above import includes the abstract syntax tree (AST) library, which is used for locating program elements
+to match syntactic elements in the source code. This can be used for example to find values, patterns and structures.


Suggested change

to match syntactic elements in the source code. This can be used for example to find values, patterns and structures.

to match syntactic elements in the source code. This can be used to find values, patterns, and structures.

sunbrye · 2025-06-19T17:32:45Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+The CodeQL libraries model various aspects of Rust code. The above import includes the abstract syntax tree (AST) library, which is used for locating program elements
+to match syntactic elements in the source code. This can be used for example to find values, patterns and structures.
+
+The control flow graph (CFG) is imported using


Suggested change

The control flow graph (CFG) is imported using

The control flow graph (CFG) is imported using:

sunbrye · 2025-06-19T17:35:36Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+The CFG models the control flow between statements and expressions, for example whether one expression can
+be evaluated before another expression, or whether an expression "dominates" another one, meaning that all paths to an
+expression must flow through another expression first.


Suggested change

The CFG models the control flow between statements and expressions, for example whether one expression can

be evaluated before another expression, or whether an expression "dominates" another one, meaning that all paths to an

expression must flow through another expression first.

The CFG models the control flow between statements and expressions. For example, it can determine whether one expression can

be evaluated before another expression, or whether an expression "dominates" another one, meaning that all paths to an

expression must flow through another expression first.

sunbrye · 2025-06-19T17:35:46Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+be evaluated before another expression, or whether an expression "dominates" another one, meaning that all paths to an
+expression must flow through another expression first.
+
+The data flow library is imported using


Suggested change

The data flow library is imported using

The data flow library is imported using:

sunbrye · 2025-06-19T17:42:12Z

docs/codeql/codeql-language-guides/codeql-library-for-rust.rst

+Data flow tracks the flow of data through the program, including through function calls (interprocedural data flow) and between steps in a job or workflow.
+Data flow is particularly useful for security queries, where untrusted data flows to vulnerable parts of the program. Related to data flow is the taint-tracking library,
+which finds how data can *influence* other values in a program, even when it is not copied exactly.


Suggested change

Data flow tracks the flow of data through the program, including through function calls (interprocedural data flow) and between steps in a job or workflow.

Data flow is particularly useful for security queries, where untrusted data flows to vulnerable parts of the program. Related to data flow is the taint-tracking library,

which finds how data can *influence* other values in a program, even when it is not copied exactly.

Data flow tracks the flow of data through the program, including across function calls (interprocedural data flow) and between steps in a job or workflow.

Data flow is particularly useful for security queries, where untrusted data flows to vulnerable parts of the program. The taint-tracking library is related to data flow,

and helps you find how data can *influence* other values in a program, even when it is not copied exactly.

Rust: start preparing documentation changes

00f6d9b

github-actions bot added the documentation label Apr 11, 2025

Rust: add supported frameworks file

df427f7

redsun82 changed the title ~~Rust: start preparing documentation changes~~ Rust: update supported languages and frameworks Apr 11, 2025

Rust: update supported languages footnote

33c857c

geoffw0 reviewed Apr 15, 2025

View reviewed changes

docs/codeql/reusables/supported-frameworks.rst Show resolved Hide resolved

docs/codeql/reusables/supported-frameworks.rst Show resolved Hide resolved

docs/codeql/reusables/supported-frameworks.rst Show resolved Hide resolved

aibaars previously approved these changes Apr 15, 2025

View reviewed changes

Rust: update supported libraries

e2a86aa

Co-authored-by: Geoffrey White <[email protected]>

redsun82 dismissed aibaars’s stale review via e2a86aa May 2, 2025 11:18

Rust: add some more supported libraries

00f4bfd

Co-authored-by: Geoffrey White <[email protected]>

geoffw0 previously approved these changes May 2, 2025

View reviewed changes

redsun82 added 3 commits June 6, 2025 14:25

Merge branch 'main' into redsun82/rust-doc

779d06f

Rust: add Callable::getParam and CallExprBase::getArg shortcuts

c70decb

Rust: add documentation

f3e4f94

redsun82 dismissed geoffw0’s stale review via f3e4f94 June 6, 2025 14:19

github-actions bot added the Rust Pull requests that update Rust code label Jun 6, 2025

github-advanced-security bot found potential problems Jun 6, 2025

View reviewed changes

rust/ql/lib/codeql/rust/elements/Callable.qll Fixed Show fixed Hide fixed

rust/ql/lib/codeql/rust/elements/internal/generated/CallExprBase.qll Fixed Show fixed Hide fixed

rust/ql/lib/codeql/rust/elements/internal/generated/Callable.qll Fixed Show fixed Hide fixed

redsun82 added 7 commits June 10, 2025 09:30

Rust: accept test changes

9c2fea9

Rust: rerun codegen

f647b33

Merge branch 'main' into redsun82/rust-doc

48721dc

Revert "Rust: add Callable::getParam and CallExprBase::getArg sho…

3fe6ba6

…rtcuts" This reverts commit c70decb.

Revert "Rust: accept test changes"

b6aa692

This reverts commit 9c2fea9.

Revert "Rust: rerun codegen"

02c11b1

This reverts commit f647b33.

Rust: fix docs with getArgList and getParamList

902a421

github-actions bot removed the Rust Pull requests that update Rust code label Jun 10, 2025

redsun82 changed the title ~~Rust: update supported languages and frameworks~~ Rust: update docs Jun 10, 2025

redsun82 added 2 commits June 12, 2025 17:33

Merge branch 'main' into redsun82/rust-doc

e1e34df

Rust: remove now unneeded get(Arg|Param)List in the dataflow guide

c56a325

redsun82 marked this pull request as ready for review June 12, 2025 15:35

redsun82 requested a review from a team as a code owner June 12, 2025 15:35

Rust: add public preview change notes

ad3a5d7

redsun82 requested a review from a team as a code owner June 13, 2025 11:03

github-actions bot added the Rust Pull requests that update Rust code label Jun 13, 2025

geoffw0 reviewed Jun 16, 2025

View reviewed changes

hvitved reviewed Jun 17, 2025

View reviewed changes

redsun82 added the ready-for-doc-review This PR requires and is ready for review from the GitHub docs team. label Jun 17, 2025

Rust: address review on docs

e9a0710

hvitved reviewed Jun 17, 2025

View reviewed changes

docs/codeql/codeql-language-guides/analyzing-data-flow-in-rust.rst Outdated Show resolved Hide resolved

redsun82 added 5 commits June 18, 2025 14:02

Merge branch 'main' into redsun82/rust-doc

494d192

Rust: fix formatting in doc snippet

e011475

Rust: fix sphinx error

7a9f23c

Merge branch 'main' into redsun82/rust-doc

11af770

Rust: address review

f812b64

sunbrye approved these changes Jun 19, 2025

View reviewed changes

sunbrye reviewed Jun 19, 2025

View reviewed changes

		Data flow is particularly useful for security queries, where untrusted data flows to vulnerable parts of the program
		to exploit it. Related to data flow, is the taint-tracking library, which finds how data can influence other values


		## Overview

		<!-- autogenerated CWE coverage table will be added below -->

	Local data flow tracks the flow of data within a single method or callable. Local data flow is easier, faster, and more precise than global data flow. Before looking at more complex tracking, you should always consider local tracking because it is sufficient for many queries.
	Local data flow tracks the flow of data within a single method or callable. Local data flow is easier, faster, and more precise than global data flow. Before using more complex tracking, consider local tracking, as it is sufficient for many queries.

		Note that since ``asExpr`` maps from data-flow to control-flow nodes, you then need to call the ``getExpr`` member predicate on the control-flow node to map to the corresponding AST node,
		for example by writing ``node.asExpr().getExpr()``.

	Note that since ``asExpr`` maps from data-flow to control-flow nodes, you then need to call the ``getExpr`` member predicate on the control-flow node to map to the corresponding AST node,
	for example by writing ``node.asExpr().getExpr()``.
	Note that because ``asExpr`` maps from data-flow to control-flow nodes, you need to call the ``getExpr`` member predicate on the control-flow node to map to the corresponding AST node. For example, you can write ``node.asExpr().getExpr()``.

	You can apply the predicate recursively, by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localFlow``.
	You can apply the predicate recursively by using the ``+`` and ``*`` operators, or you can use the predefined recursive predicate ``localFlow``.

	When exploring local data flow or taint propagation between two expressions as above, you would normally constrain the expressions to be relevant to your investigation.
	When exploring local data flow or taint propagation between two expressions, such as in the previous example, you typically constrain the expressions to those relevant to your investigation.

	- :doc:`CodeQL library for Rust <codeql-library-for-rust>`: When you're analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.
	- :doc:`CodeQL library for Rust <codeql-library-for-rust>`: When analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.

	When you're analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.
	When analyzing Rust code, you can make use of the large collection of classes in the CodeQL library for Rust.

		Unfortunately this will only give the expression in the argument, not the values which could be passed to it.
		So we use local data flow to find all expressions that flow into the argument:

	Unfortunately this will only give the expression in the argument, not the values which could be passed to it.
	So we use local data flow to find all expressions that flow into the argument:
	Unfortunately, this only returns the expression used as the argument, not the possible values that could be passed to it. To address this, you can use local data flow to find all expressions that flow into the argument.

	We can vary the source, for example, making the source the parameter of a function rather than an expression. The following query finds where a parameter is used for the file creation:
	You can vary the source by making the source the parameter of a function instead of an expression. The following query finds where a parameter is used in file creation:

	- The sources and sinks may need tuning to a particular use, for example, if passwords are represented by a type other than ``String`` or passed in arguments of a different name than "password".
	- The sources and sinks may need to be adjusted for a particular use. For example, passwords might be represented by a type other than ``String`` or passed in arguments with a different name than "password".

	The library is implemented as a set of CodeQL modules, that is, files with the extension ``.qll``. The
	The library is implemented as a set of CodeQL modules, which are files with the extension ``.qll``. The

	to match syntactic elements in the source code. This can be used for example to find values, patterns and structures.
	to match syntactic elements in the source code. This can be used to find values, patterns, and structures.

	The control flow graph (CFG) is imported using
	The control flow graph (CFG) is imported using:

	The data flow library is imported using
	The data flow library is imported using:

Rust: update docs #19280

Are you sure you want to change the base?

Rust: update docs #19280

Conversation

redsun82 commented Apr 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

geoffw0 left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

geoffw0 left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

sunbrye left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sunbrye Jun 19, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

redsun82 commented Apr 11, 2025 •

edited

Loading

sunbrye left a comment •

edited

Loading

sunbrye Jun 19, 2025 •

edited

Loading