Nate

.github/workflows/laravel.yml

@@ -0,0 +1,35 @@
+name: Laravel
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  laravel-tests:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: shivammathur/setup-php@15c43e89cdef867065b0213be354c2841860869e
+      with:
+        php-version: '8.0'
+    - uses: actions/checkout@v3
+    - name: Copy .env
+      run: php -r "file_exists('.env') || copy('.env.example', '.env');"
+    - name: Install Dependencies
+      run: composer install -q --no-ansi --no-interaction --no-scripts --no-progress --prefer-dist
+    - name: Generate key
+      run: php artisan key:generate
+    - name: Directory Permissions
+      run: chmod -R 777 storage bootstrap/cache
+    - name: Create Database
+      run: |
+        mkdir -p database
+        touch database/database.sqlite
+    - name: Execute tests (Unit and Feature tests) via PHPUnit
+      env:
+        DB_CONNECTION: sqlite
+        DB_DATABASE: database/database.sqlite
+      run: vendor/bin/phpunit

.github/เวิร์กโฟลว์/codeql.yml

@@ -0,0 +1,288 @@
+For most projects, this workflow file will not need changing; you simply need
+ to commit it to your repository.
+
+ You may wish to alter this file to override the set of languages analyzed,
+or to provide custom queries or build logic.
+Google Online Security Blog
+
+The latest news and insights from Google on security and safety on the Internet
+
+January 12, 2023
+
+Supporting the Use of Rust in the Chromium Project
+
+Posted by Dana Jansens (she/her), Chrome Security Team
+
+We are pleased to announce that moving forward, the Chromium project is going to support the use of third-party Rust libraries from C++ in Chromium. To do so, we are now actively pursuing adding a production Rust toolchain to our build system. This will enable us to include Rust code in the Chrome binary within the next year. We’re starting slow and setting clear expectations on what libraries we will consider once we’re ready.
+
+In this blog post, we will discuss how we arrived at the decision to support third-party Rust libraries at this time, and not broader usage of Rust in Chromium.
+
+Why We Chose to Bring Rust into Chromium
+
+Our goal in bringing Rust into Chromium is to provide a simpler (no IPC) and safer (less complex C++ overall, no memory safety bugs in a sandbox either) way to satisfy the rule of two, in order to speed up development (less code to write, less design docs, less security review) and improve the security (increasing the number of lines of code without memory safety bugs, decreasing the bug density of code) of Chrome. And we believe that we can use third-party Rust libraries to work toward this goal.
+
+Rust was developed by Mozilla specifically for use in writing a browser, so it’s very fitting that Chromium would finally begin to rely on this technology too. Thank you Mozilla for your huge contribution to the systems software industry. Rust has been an incredible proof that we should be able to expect a language to provide safety while also being performant.
+
+We know that C++ and Rust can play together nicely, through tools like cxx, autocxx bindgen, cbindgen, diplomat, and (experimental) crubit. However there are also limitations. We can expect that the shape of these limitations will change in time through new or improved tools, but the decisions and descriptions here are based on the current state of technology.
+
+How Chromium Will Support the Use of Rust
+
+The Chrome Security team has been investing time into researching how we should approach using Rust alongside our C++ code. Understanding the implications of incrementally moving to writing Rust instead of C++, even in the middle of our software stack. What the limits of safe, simple, and reliable interop might be.
+
+Based on our research, we landed on two outcomes for Chromium.
+
+We will support interop in only a single direction, from C++ to Rust, for now. Chromium is written in C++, and the majority of stack frames are in C++ code, right from main() until exit(), which is why we chose this direction. By limiting interop to a single direction, we control the shape of the dependency tree. Rust can not depend on C++ so it cannot know about C++ types and functions, except through dependency injection. In this way, Rust can not land in arbitrary C++ code, only in functions passed through the API from C++.
+
+We will only support third-party libraries for now. Third-party libraries are written as standalone components, they don’t hold implicit knowledge about the implementation of Chromium. This means they have APIs that are simpler and focused on their single task. Or, put another way, they typically have a narrow interface, without complex pointer graphs and shared ownership. We will be reviewing libraries that we bring in for C++ use to ensure they fit this expectation.
+
+The Interop Between Rust and C++ in Chromium
+
+We have observed that most successful C/C++ and Rust interop stories to date have been built around interop through narrow APIs (e.g. libraries for QUIC or bluetooth, Linux drivers) or through clearly isolated components (e.g. IDLs, IPCs). Chrome is built on foundational but really wide C++ APIs, such as the //content/public layer. We examined what it would mean for us to build Rust components against these types of APIs. At a high level what we found was that because C++ and Rust play by different rules, things can go sideways very easily.
+
+For example, Rust guarantees temporal memory safety with static analysis that relies on two inputs: lifetimes (inferred or explicitly written) and exclusive mutability. The latter is incompatible with how the majority of Chromium’s C++ is written. We hold redundant mutable pointers throughout the system, and pointers that provide multiple paths to reach mutable pointers. We have cyclical mutable data structures. This is especially true in our browser process, which contains a giant interconnected system of (mutable) pointers. If these C++ pointers were also used as Rust references in a complex or long-lived way, it would require our C++ authors to understand the aliasing rules of Rust and prevent the possibility of violating them, such as by:
+
+Returning the same mutable pointer from a function twice, where the first may still be held.
+
+Passing overlapping pointers where one is mutable into Rust, in a way that they may be held as references at the same time.
+
+Mutating state that is visible to Rust through a shared or mutable reference.
+
+Without interop tools providing support via the compiler and the type system, developers would need to understand all of the assumptions being made by Rust compiler, in order to not violate them from C++. In this framing, C++ is much like unsafe Rust. And while unsafe Rust is very costly to a project, its cost is managed by keeping it encapsulated and to the minimum possible. In the same way, the full complexity of C++ would need to be encapsulated from safe Rust. Narrow APIs designed for interop can provide similar encapsulation, and we hope that interop tools can provide encapsulation in other ways that allow wider APIs between the languages.
+
+The high-level summary is that without additional interop tooling support:
+
+Passing pointers/references across languages is risky.
+
+Narrow interfaces between the languages is critical to make it feasible to write code correctly.
+
+Any cross-language interop between arbitrary code introduces difficulties where concepts in one language are not found in the other. For Rust calling into C++, support for language features like templates or inheritance can be difficult for a binding generator to support. For C++ calling into Rust, proc macros, and traits are examples that provide similar challenges. At times, the impedance mismatch represents intentional design choices made for either language, however they also imply limits on FFI (interop) between the languages. We rely on interop tools to model the ideas of each language in a way that makes sense to the other, or to disallow them.
+
+Accessing the Rust Ecosystem from Chromium
+
+These challenges present an opportunity, both to make interop easier and more seamless, but also to get access to a wider range of libraries from either language. Google is investing in Crubit, an experiment in how to increase the fidelity of interop between C++ and Rust and express or encapsulate the requirements of each language to the other.
+
+The Rust ecosystem is incredibly important, especially to a security-focused open source project like Chromium. The ecosystem is enormous (96k+ crates on crates.io) and growing, with investment from the systems development industry at large, including Google. Chrome relies heavily on third-party code, and we need to keep up with where that third-party investment is happening. It is critical that we build out support for including Rust into the Chromium project.
+
+We will be following this strategy to establish norms, and to maintain a level of API review through the third-party process, while we look to the future of interop support pushing the boundaries of what is possible and reasonable to do between Rust and C++.
+
+Some Other Related Content
+
+Memory unsafety is an industry-wide problem, and making use of Rust is one part of a strategy to move the needle in this area. Recently, Android and Apple have each published a great blog post on the subject if you’re interested in learning more. With Chrome’s millions of lines of C++, we’re still working hard to improve the safety of our C++ too, through projects such as MiraclePtr.
+
+Edward Fernandez
+
+Share
+
+No comments:https://doc.rust-lang.org/rust-by-example/scope/borrow/ref.html
+
+Post a Comment
+
+You are welcome to contribute comments, but they should be relevant to the conversation. We reserve the right to remove off-topic remarks in the interest of keeping the conversation focused and engaging. Shameless self-promotion is well, shameless, and will get canned.
+
+Note: Only a member of this blog may post a comment.
+
+‹
+
+›
+
+Home
+
+View web version
+
+Powered by Blogger.
+https://doc.rust-lang.org/rust-by-example/scope/borrow/ref.html
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    สาขา: [   "หลัก"  #[derive(Clone, Copy)]
+
+struct Point { x: i32, y: i32 }
+
+fn main() {
+
+    let c = 'Q';
+
+    // A `ref` borrow on the left side of an assignment is equivalent to
+
+    // an `&` borrow on the right side.
+
+    let ref ref_c1 = c;
+
+    let ref_c2 = &c;
+
+    println!("ref_c1 equals ref_c2: {}", *ref_c1 == *ref_c2);
+
+    let point = Point { x: 0, y: 0 };
+
+    // `ref` is also valid when destructuring a struct.
+
+    let _copy_of_x = {
+
+        // `ref_to_x` is a reference to the `x` field of `point`.
+
+        let Point { x: ref ref_to_x, y: _ } = point;
+
+        // Return a copy of the `x` field of `point`.
+
+        *ref_to_x
+
+    };
+
+    // A mutable copy of `point`
+
+    let mut mutable_point = point;
+
+    {
+
+        // `ref` can be paired with `mut` to take mutable references.
+
+        let Point { x: _, y: ref mut mut_ref_to_y } = mutable_point;
+
+        // Mutate the `y` field of `mutable_point` via a mutable reference.
+
+        *mut_ref_to_y = 1;
+
+    }
+
+    println!("point is ({}, {})", point.x, point.y);
+
+    println!("mutable_point is ({}, {})", mutable_point.x, mutable_point.y);
+
+    // A mutable tuple that includes a pointer
+
+    let mut mutable_tuple = (Box::new(5u32), 3u32);
+
+
+
+    {
+
+        // Destructure `mutable_tuple` to change the value of `last`.
+
+        let (_, ref mut last) = mutable_tuple;
+
+        *last = 2u32;
+
+    }
+
+
+
+    println!("tuple is {:?}", mutable_tuple);
+
+}
+
+ ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    สาขา: [  "หลัก" ref_c1 equals ref_c2: true
+
+point is (0, 0)
+
+mutable_point is (0, 1)
+
+tuple is (5, 2) ]
+  schedule:
+    - cron: '39 2 * * 5'
+
+งาน:
+  วิเคราะห์// Lifetimes are annotated below with lines denoting the creation
+
+// and destruction of each variable.
+
+// `i` has the longest lifetime because its scope entirely encloses 
+
+// both `borrow1` and `borrow2`. The duration of `borrow1` compared 
+
+// to `borrow2` is irrelevant since they are disjoint.
+
+fn main() {
+
+    let i = 3; // Lifetime for `i` starts. ────────────────┐
+
+    //                                                     │
+
+    { //                                                   │
+
+        let borrow1 = &i; // `borrow1` lifetime starts. ──┐│
+
+        //                                                ││
+
+        println!("borrow1: {nate15872}", borrow1); //              ││
+
+    } // `borrow1 ends. ──────────────────────────────────┘│
+
+    //                                                     │
+
+    //                                                     │
+
+    { //                                                   │
+
+        let borrow2 = &i; // `borrow2` lifetime starts. ──┐│
+
+        //                                                ││
+
+        println!("borrow2: {nate15872}", borrow2); //              ││
+
+    } // `borrow2` ends. ─────────────────────────────────┘│
+
+    //                                                     │
+
+}   // Lifetime ends. ─────────────────────────────────────┘
+
+:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'cpp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Use only 'java' to analyze code written in Java, Kotlin or both
+        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #     echo "Run, Build Application using script"
+    #     ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"