├── .envrc ├── .github ├── renovate.json └── workflows │ └── ci.yml ├── .gitignore ├── LICENSE ├── README.md ├── flake.lock ├── flake.nix ├── nix ├── module.nix └── tests │ ├── can-fetch-files.nix │ └── default.nix └── ws ├── Cargo.lock ├── Cargo.toml ├── obiwan ├── Cargo.toml └── src │ ├── main.rs │ ├── path.rs │ ├── simple_fs.rs │ ├── simple_proto.rs │ ├── tftp.rs │ └── tftp_proto.rs └── rustfmt.toml /.envrc: -------------------------------------------------------------------------------- 1 | use flake 2 | -------------------------------------------------------------------------------- /.github/renovate.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://docs.renovatebot.com/renovate-schema.json", 3 | "extends": [ 4 | "config:base" 5 | ], 6 | "lockFileMaintenance": { 7 | "enabled": true 8 | }, 9 | "packageRules": [ 10 | { 11 | "groupName": "all non-major dependencies", 12 | "groupSlug": "all-minor-patch", 13 | "matchPackagePatterns": [ 14 | "*" 15 | ], 16 | "matchUpdateTypes": [ 17 | "minor", 18 | "patch" 19 | ], 20 | "automerge": true 21 | } 22 | ], 23 | "nix": { 24 | "enabled": true 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | on: 2 | pull_request: 3 | push: 4 | branches: [master] 5 | 6 | jobs: 7 | test: 8 | name: Test 9 | runs-on: ubuntu-24.04 10 | steps: 11 | - uses: actions/checkout@v4 12 | - name: Install Nix 13 | uses: DeterminateSystems/nix-installer-action@v13 14 | - name: Run `nix -L build` 15 | run: nix -L build 16 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /ws/target 2 | /.direnv 3 | /.pre-commit-config.yaml 4 | /result* 5 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU AFFERO GENERAL PUBLIC LICENSE 2 | Version 3, 19 November 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU Affero General Public License is a free, copyleft license for 11 | software and other kinds of works, specifically designed to ensure 12 | cooperation with the community in the case of network server software. 13 | 14 | The licenses for most software and other practical works are designed 15 | to take away your freedom to share and change the works. By contrast, 16 | our General Public Licenses are intended to guarantee your freedom to 17 | share and change all versions of a program--to make sure it remains free 18 | software for all its users. 19 | 20 | When we speak of free software, we are referring to freedom, not 21 | price. Our General Public Licenses are designed to make sure that you 22 | have the freedom to distribute copies of free software (and charge for 23 | them if you wish), that you receive source code or can get it if you 24 | want it, that you can change the software or use pieces of it in new 25 | free programs, and that you know you can do these things. 26 | 27 | Developers that use our General Public Licenses protect your rights 28 | with two steps: (1) assert copyright on the software, and (2) offer 29 | you this License which gives you legal permission to copy, distribute 30 | and/or modify the software. 31 | 32 | A secondary benefit of defending all users' freedom is that 33 | improvements made in alternate versions of the program, if they 34 | receive widespread use, become available for other developers to 35 | incorporate. Many developers of free software are heartened and 36 | encouraged by the resulting cooperation. However, in the case of 37 | software used on network servers, this result may fail to come about. 38 | The GNU General Public License permits making a modified version and 39 | letting the public access it on a server without ever releasing its 40 | source code to the public. 41 | 42 | The GNU Affero General Public License is designed specifically to 43 | ensure that, in such cases, the modified source code becomes available 44 | to the community. It requires the operator of a network server to 45 | provide the source code of the modified version running there to the 46 | users of that server. Therefore, public use of a modified version, on 47 | a publicly accessible server, gives the public access to the source 48 | code of the modified version. 49 | 50 | An older license, called the Affero General Public License and 51 | published by Affero, was designed to accomplish similar goals. This is 52 | a different license, not a version of the Affero GPL, but Affero has 53 | released a new version of the Affero GPL which permits relicensing under 54 | this license. 55 | 56 | The precise terms and conditions for copying, distribution and 57 | modification follow. 58 | 59 | TERMS AND CONDITIONS 60 | 61 | 0. Definitions. 62 | 63 | "This License" refers to version 3 of the GNU Affero General Public License. 64 | 65 | "Copyright" also means copyright-like laws that apply to other kinds of 66 | works, such as semiconductor masks. 67 | 68 | "The Program" refers to any copyrightable work licensed under this 69 | License. Each licensee is addressed as "you". "Licensees" and 70 | "recipients" may be individuals or organizations. 71 | 72 | To "modify" a work means to copy from or adapt all or part of the work 73 | in a fashion requiring copyright permission, other than the making of an 74 | exact copy. The resulting work is called a "modified version" of the 75 | earlier work or a work "based on" the earlier work. 76 | 77 | A "covered work" means either the unmodified Program or a work based 78 | on the Program. 79 | 80 | To "propagate" a work means to do anything with it that, without 81 | permission, would make you directly or secondarily liable for 82 | infringement under applicable copyright law, except executing it on a 83 | computer or modifying a private copy. Propagation includes copying, 84 | distribution (with or without modification), making available to the 85 | public, and in some countries other activities as well. 86 | 87 | To "convey" a work means any kind of propagation that enables other 88 | parties to make or receive copies. Mere interaction with a user through 89 | a computer network, with no transfer of a copy, is not conveying. 90 | 91 | An interactive user interface displays "Appropriate Legal Notices" 92 | to the extent that it includes a convenient and prominently visible 93 | feature that (1) displays an appropriate copyright notice, and (2) 94 | tells the user that there is no warranty for the work (except to the 95 | extent that warranties are provided), that licensees may convey the 96 | work under this License, and how to view a copy of this License. If 97 | the interface presents a list of user commands or options, such as a 98 | menu, a prominent item in the list meets this criterion. 99 | 100 | 1. Source Code. 101 | 102 | The "source code" for a work means the preferred form of the work 103 | for making modifications to it. "Object code" means any non-source 104 | form of a work. 105 | 106 | A "Standard Interface" means an interface that either is an official 107 | standard defined by a recognized standards body, or, in the case of 108 | interfaces specified for a particular programming language, one that 109 | is widely used among developers working in that language. 110 | 111 | The "System Libraries" of an executable work include anything, other 112 | than the work as a whole, that (a) is included in the normal form of 113 | packaging a Major Component, but which is not part of that Major 114 | Component, and (b) serves only to enable use of the work with that 115 | Major Component, or to implement a Standard Interface for which an 116 | implementation is available to the public in source code form. A 117 | "Major Component", in this context, means a major essential component 118 | (kernel, window system, and so on) of the specific operating system 119 | (if any) on which the executable work runs, or a compiler used to 120 | produce the work, or an object code interpreter used to run it. 121 | 122 | The "Corresponding Source" for a work in object code form means all 123 | the source code needed to generate, install, and (for an executable 124 | work) run the object code and to modify the work, including scripts to 125 | control those activities. However, it does not include the work's 126 | System Libraries, or general-purpose tools or generally available free 127 | programs which are used unmodified in performing those activities but 128 | which are not part of the work. For example, Corresponding Source 129 | includes interface definition files associated with source files for 130 | the work, and the source code for shared libraries and dynamically 131 | linked subprograms that the work is specifically designed to require, 132 | such as by intimate data communication or control flow between those 133 | subprograms and other parts of the work. 134 | 135 | The Corresponding Source need not include anything that users 136 | can regenerate automatically from other parts of the Corresponding 137 | Source. 138 | 139 | The Corresponding Source for a work in source code form is that 140 | same work. 141 | 142 | 2. Basic Permissions. 143 | 144 | All rights granted under this License are granted for the term of 145 | copyright on the Program, and are irrevocable provided the stated 146 | conditions are met. This License explicitly affirms your unlimited 147 | permission to run the unmodified Program. The output from running a 148 | covered work is covered by this License only if the output, given its 149 | content, constitutes a covered work. This License acknowledges your 150 | rights of fair use or other equivalent, as provided by copyright law. 151 | 152 | You may make, run and propagate covered works that you do not 153 | convey, without conditions so long as your license otherwise remains 154 | in force. You may convey covered works to others for the sole purpose 155 | of having them make modifications exclusively for you, or provide you 156 | with facilities for running those works, provided that you comply with 157 | the terms of this License in conveying all material for which you do 158 | not control copyright. Those thus making or running the covered works 159 | for you must do so exclusively on your behalf, under your direction 160 | and control, on terms that prohibit them from making any copies of 161 | your copyrighted material outside their relationship with you. 162 | 163 | Conveying under any other circumstances is permitted solely under 164 | the conditions stated below. Sublicensing is not allowed; section 10 165 | makes it unnecessary. 166 | 167 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 168 | 169 | No covered work shall be deemed part of an effective technological 170 | measure under any applicable law fulfilling obligations under article 171 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 172 | similar laws prohibiting or restricting circumvention of such 173 | measures. 174 | 175 | When you convey a covered work, you waive any legal power to forbid 176 | circumvention of technological measures to the extent such circumvention 177 | is effected by exercising rights under this License with respect to 178 | the covered work, and you disclaim any intention to limit operation or 179 | modification of the work as a means of enforcing, against the work's 180 | users, your or third parties' legal rights to forbid circumvention of 181 | technological measures. 182 | 183 | 4. Conveying Verbatim Copies. 184 | 185 | You may convey verbatim copies of the Program's source code as you 186 | receive it, in any medium, provided that you conspicuously and 187 | appropriately publish on each copy an appropriate copyright notice; 188 | keep intact all notices stating that this License and any 189 | non-permissive terms added in accord with section 7 apply to the code; 190 | keep intact all notices of the absence of any warranty; and give all 191 | recipients a copy of this License along with the Program. 192 | 193 | You may charge any price or no price for each copy that you convey, 194 | and you may offer support or warranty protection for a fee. 195 | 196 | 5. Conveying Modified Source Versions. 197 | 198 | You may convey a work based on the Program, or the modifications to 199 | produce it from the Program, in the form of source code under the 200 | terms of section 4, provided that you also meet all of these conditions: 201 | 202 | a) The work must carry prominent notices stating that you modified 203 | it, and giving a relevant date. 204 | 205 | b) The work must carry prominent notices stating that it is 206 | released under this License and any conditions added under section 207 | 7. This requirement modifies the requirement in section 4 to 208 | "keep intact all notices". 209 | 210 | c) You must license the entire work, as a whole, under this 211 | License to anyone who comes into possession of a copy. This 212 | License will therefore apply, along with any applicable section 7 213 | additional terms, to the whole of the work, and all its parts, 214 | regardless of how they are packaged. This License gives no 215 | permission to license the work in any other way, but it does not 216 | invalidate such permission if you have separately received it. 217 | 218 | d) If the work has interactive user interfaces, each must display 219 | Appropriate Legal Notices; however, if the Program has interactive 220 | interfaces that do not display Appropriate Legal Notices, your 221 | work need not make them do so. 222 | 223 | A compilation of a covered work with other separate and independent 224 | works, which are not by their nature extensions of the covered work, 225 | and which are not combined with it such as to form a larger program, 226 | in or on a volume of a storage or distribution medium, is called an 227 | "aggregate" if the compilation and its resulting copyright are not 228 | used to limit the access or legal rights of the compilation's users 229 | beyond what the individual works permit. Inclusion of a covered work 230 | in an aggregate does not cause this License to apply to the other 231 | parts of the aggregate. 232 | 233 | 6. Conveying Non-Source Forms. 234 | 235 | You may convey a covered work in object code form under the terms 236 | of sections 4 and 5, provided that you also convey the 237 | machine-readable Corresponding Source under the terms of this License, 238 | in one of these ways: 239 | 240 | a) Convey the object code in, or embodied in, a physical product 241 | (including a physical distribution medium), accompanied by the 242 | Corresponding Source fixed on a durable physical medium 243 | customarily used for software interchange. 244 | 245 | b) Convey the object code in, or embodied in, a physical product 246 | (including a physical distribution medium), accompanied by a 247 | written offer, valid for at least three years and valid for as 248 | long as you offer spare parts or customer support for that product 249 | model, to give anyone who possesses the object code either (1) a 250 | copy of the Corresponding Source for all the software in the 251 | product that is covered by this License, on a durable physical 252 | medium customarily used for software interchange, for a price no 253 | more than your reasonable cost of physically performing this 254 | conveying of source, or (2) access to copy the 255 | Corresponding Source from a network server at no charge. 256 | 257 | c) Convey individual copies of the object code with a copy of the 258 | written offer to provide the Corresponding Source. This 259 | alternative is allowed only occasionally and noncommercially, and 260 | only if you received the object code with such an offer, in accord 261 | with subsection 6b. 262 | 263 | d) Convey the object code by offering access from a designated 264 | place (gratis or for a charge), and offer equivalent access to the 265 | Corresponding Source in the same way through the same place at no 266 | further charge. You need not require recipients to copy the 267 | Corresponding Source along with the object code. If the place to 268 | copy the object code is a network server, the Corresponding Source 269 | may be on a different server (operated by you or a third party) 270 | that supports equivalent copying facilities, provided you maintain 271 | clear directions next to the object code saying where to find the 272 | Corresponding Source. Regardless of what server hosts the 273 | Corresponding Source, you remain obligated to ensure that it is 274 | available for as long as needed to satisfy these requirements. 275 | 276 | e) Convey the object code using peer-to-peer transmission, provided 277 | you inform other peers where the object code and Corresponding 278 | Source of the work are being offered to the general public at no 279 | charge under subsection 6d. 280 | 281 | A separable portion of the object code, whose source code is excluded 282 | from the Corresponding Source as a System Library, need not be 283 | included in conveying the object code work. 284 | 285 | A "User Product" is either (1) a "consumer product", which means any 286 | tangible personal property which is normally used for personal, family, 287 | or household purposes, or (2) anything designed or sold for incorporation 288 | into a dwelling. In determining whether a product is a consumer product, 289 | doubtful cases shall be resolved in favor of coverage. For a particular 290 | product received by a particular user, "normally used" refers to a 291 | typical or common use of that class of product, regardless of the status 292 | of the particular user or of the way in which the particular user 293 | actually uses, or expects or is expected to use, the product. A product 294 | is a consumer product regardless of whether the product has substantial 295 | commercial, industrial or non-consumer uses, unless such uses represent 296 | the only significant mode of use of the product. 297 | 298 | "Installation Information" for a User Product means any methods, 299 | procedures, authorization keys, or other information required to install 300 | and execute modified versions of a covered work in that User Product from 301 | a modified version of its Corresponding Source. The information must 302 | suffice to ensure that the continued functioning of the modified object 303 | code is in no case prevented or interfered with solely because 304 | modification has been made. 305 | 306 | If you convey an object code work under this section in, or with, or 307 | specifically for use in, a User Product, and the conveying occurs as 308 | part of a transaction in which the right of possession and use of the 309 | User Product is transferred to the recipient in perpetuity or for a 310 | fixed term (regardless of how the transaction is characterized), the 311 | Corresponding Source conveyed under this section must be accompanied 312 | by the Installation Information. But this requirement does not apply 313 | if neither you nor any third party retains the ability to install 314 | modified object code on the User Product (for example, the work has 315 | been installed in ROM). 316 | 317 | The requirement to provide Installation Information does not include a 318 | requirement to continue to provide support service, warranty, or updates 319 | for a work that has been modified or installed by the recipient, or for 320 | the User Product in which it has been modified or installed. Access to a 321 | network may be denied when the modification itself materially and 322 | adversely affects the operation of the network or violates the rules and 323 | protocols for communication across the network. 324 | 325 | Corresponding Source conveyed, and Installation Information provided, 326 | in accord with this section must be in a format that is publicly 327 | documented (and with an implementation available to the public in 328 | source code form), and must require no special password or key for 329 | unpacking, reading or copying. 330 | 331 | 7. Additional Terms. 332 | 333 | "Additional permissions" are terms that supplement the terms of this 334 | License by making exceptions from one or more of its conditions. 335 | Additional permissions that are applicable to the entire Program shall 336 | be treated as though they were included in this License, to the extent 337 | that they are valid under applicable law. If additional permissions 338 | apply only to part of the Program, that part may be used separately 339 | under those permissions, but the entire Program remains governed by 340 | this License without regard to the additional permissions. 341 | 342 | When you convey a copy of a covered work, you may at your option 343 | remove any additional permissions from that copy, or from any part of 344 | it. (Additional permissions may be written to require their own 345 | removal in certain cases when you modify the work.) You may place 346 | additional permissions on material, added by you to a covered work, 347 | for which you have or can give appropriate copyright permission. 348 | 349 | Notwithstanding any other provision of this License, for material you 350 | add to a covered work, you may (if authorized by the copyright holders of 351 | that material) supplement the terms of this License with terms: 352 | 353 | a) Disclaiming warranty or limiting liability differently from the 354 | terms of sections 15 and 16 of this License; or 355 | 356 | b) Requiring preservation of specified reasonable legal notices or 357 | author attributions in that material or in the Appropriate Legal 358 | Notices displayed by works containing it; or 359 | 360 | c) Prohibiting misrepresentation of the origin of that material, or 361 | requiring that modified versions of such material be marked in 362 | reasonable ways as different from the original version; or 363 | 364 | d) Limiting the use for publicity purposes of names of licensors or 365 | authors of the material; or 366 | 367 | e) Declining to grant rights under trademark law for use of some 368 | trade names, trademarks, or service marks; or 369 | 370 | f) Requiring indemnification of licensors and authors of that 371 | material by anyone who conveys the material (or modified versions of 372 | it) with contractual assumptions of liability to the recipient, for 373 | any liability that these contractual assumptions directly impose on 374 | those licensors and authors. 375 | 376 | All other non-permissive additional terms are considered "further 377 | restrictions" within the meaning of section 10. If the Program as you 378 | received it, or any part of it, contains a notice stating that it is 379 | governed by this License along with a term that is a further 380 | restriction, you may remove that term. If a license document contains 381 | a further restriction but permits relicensing or conveying under this 382 | License, you may add to a covered work material governed by the terms 383 | of that license document, provided that the further restriction does 384 | not survive such relicensing or conveying. 385 | 386 | If you add terms to a covered work in accord with this section, you 387 | must place, in the relevant source files, a statement of the 388 | additional terms that apply to those files, or a notice indicating 389 | where to find the applicable terms. 390 | 391 | Additional terms, permissive or non-permissive, may be stated in the 392 | form of a separately written license, or stated as exceptions; 393 | the above requirements apply either way. 394 | 395 | 8. Termination. 396 | 397 | You may not propagate or modify a covered work except as expressly 398 | provided under this License. Any attempt otherwise to propagate or 399 | modify it is void, and will automatically terminate your rights under 400 | this License (including any patent licenses granted under the third 401 | paragraph of section 11). 402 | 403 | However, if you cease all violation of this License, then your 404 | license from a particular copyright holder is reinstated (a) 405 | provisionally, unless and until the copyright holder explicitly and 406 | finally terminates your license, and (b) permanently, if the copyright 407 | holder fails to notify you of the violation by some reasonable means 408 | prior to 60 days after the cessation. 409 | 410 | Moreover, your license from a particular copyright holder is 411 | reinstated permanently if the copyright holder notifies you of the 412 | violation by some reasonable means, this is the first time you have 413 | received notice of violation of this License (for any work) from that 414 | copyright holder, and you cure the violation prior to 30 days after 415 | your receipt of the notice. 416 | 417 | Termination of your rights under this section does not terminate the 418 | licenses of parties who have received copies or rights from you under 419 | this License. If your rights have been terminated and not permanently 420 | reinstated, you do not qualify to receive new licenses for the same 421 | material under section 10. 422 | 423 | 9. Acceptance Not Required for Having Copies. 424 | 425 | You are not required to accept this License in order to receive or 426 | run a copy of the Program. Ancillary propagation of a covered work 427 | occurring solely as a consequence of using peer-to-peer transmission 428 | to receive a copy likewise does not require acceptance. However, 429 | nothing other than this License grants you permission to propagate or 430 | modify any covered work. These actions infringe copyright if you do 431 | not accept this License. Therefore, by modifying or propagating a 432 | covered work, you indicate your acceptance of this License to do so. 433 | 434 | 10. Automatic Licensing of Downstream Recipients. 435 | 436 | Each time you convey a covered work, the recipient automatically 437 | receives a license from the original licensors, to run, modify and 438 | propagate that work, subject to this License. You are not responsible 439 | for enforcing compliance by third parties with this License. 440 | 441 | An "entity transaction" is a transaction transferring control of an 442 | organization, or substantially all assets of one, or subdividing an 443 | organization, or merging organizations. If propagation of a covered 444 | work results from an entity transaction, each party to that 445 | transaction who receives a copy of the work also receives whatever 446 | licenses to the work the party's predecessor in interest had or could 447 | give under the previous paragraph, plus a right to possession of the 448 | Corresponding Source of the work from the predecessor in interest, if 449 | the predecessor has it or can get it with reasonable efforts. 450 | 451 | You may not impose any further restrictions on the exercise of the 452 | rights granted or affirmed under this License. For example, you may 453 | not impose a license fee, royalty, or other charge for exercise of 454 | rights granted under this License, and you may not initiate litigation 455 | (including a cross-claim or counterclaim in a lawsuit) alleging that 456 | any patent claim is infringed by making, using, selling, offering for 457 | sale, or importing the Program or any portion of it. 458 | 459 | 11. Patents. 460 | 461 | A "contributor" is a copyright holder who authorizes use under this 462 | License of the Program or a work on which the Program is based. The 463 | work thus licensed is called the contributor's "contributor version". 464 | 465 | A contributor's "essential patent claims" are all patent claims 466 | owned or controlled by the contributor, whether already acquired or 467 | hereafter acquired, that would be infringed by some manner, permitted 468 | by this License, of making, using, or selling its contributor version, 469 | but do not include claims that would be infringed only as a 470 | consequence of further modification of the contributor version. For 471 | purposes of this definition, "control" includes the right to grant 472 | patent sublicenses in a manner consistent with the requirements of 473 | this License. 474 | 475 | Each contributor grants you a non-exclusive, worldwide, royalty-free 476 | patent license under the contributor's essential patent claims, to 477 | make, use, sell, offer for sale, import and otherwise run, modify and 478 | propagate the contents of its contributor version. 479 | 480 | In the following three paragraphs, a "patent license" is any express 481 | agreement or commitment, however denominated, not to enforce a patent 482 | (such as an express permission to practice a patent or covenant not to 483 | sue for patent infringement). To "grant" such a patent license to a 484 | party means to make such an agreement or commitment not to enforce a 485 | patent against the party. 486 | 487 | If you convey a covered work, knowingly relying on a patent license, 488 | and the Corresponding Source of the work is not available for anyone 489 | to copy, free of charge and under the terms of this License, through a 490 | publicly available network server or other readily accessible means, 491 | then you must either (1) cause the Corresponding Source to be so 492 | available, or (2) arrange to deprive yourself of the benefit of the 493 | patent license for this particular work, or (3) arrange, in a manner 494 | consistent with the requirements of this License, to extend the patent 495 | license to downstream recipients. "Knowingly relying" means you have 496 | actual knowledge that, but for the patent license, your conveying the 497 | covered work in a country, or your recipient's use of the covered work 498 | in a country, would infringe one or more identifiable patents in that 499 | country that you have reason to believe are valid. 500 | 501 | If, pursuant to or in connection with a single transaction or 502 | arrangement, you convey, or propagate by procuring conveyance of, a 503 | covered work, and grant a patent license to some of the parties 504 | receiving the covered work authorizing them to use, propagate, modify 505 | or convey a specific copy of the covered work, then the patent license 506 | you grant is automatically extended to all recipients of the covered 507 | work and works based on it. 508 | 509 | A patent license is "discriminatory" if it does not include within 510 | the scope of its coverage, prohibits the exercise of, or is 511 | conditioned on the non-exercise of one or more of the rights that are 512 | specifically granted under this License. You may not convey a covered 513 | work if you are a party to an arrangement with a third party that is 514 | in the business of distributing software, under which you make payment 515 | to the third party based on the extent of your activity of conveying 516 | the work, and under which the third party grants, to any of the 517 | parties who would receive the covered work from you, a discriminatory 518 | patent license (a) in connection with copies of the covered work 519 | conveyed by you (or copies made from those copies), or (b) primarily 520 | for and in connection with specific products or compilations that 521 | contain the covered work, unless you entered into that arrangement, 522 | or that patent license was granted, prior to 28 March 2007. 523 | 524 | Nothing in this License shall be construed as excluding or limiting 525 | any implied license or other defenses to infringement that may 526 | otherwise be available to you under applicable patent law. 527 | 528 | 12. No Surrender of Others' Freedom. 529 | 530 | If conditions are imposed on you (whether by court order, agreement or 531 | otherwise) that contradict the conditions of this License, they do not 532 | excuse you from the conditions of this License. If you cannot convey a 533 | covered work so as to satisfy simultaneously your obligations under this 534 | License and any other pertinent obligations, then as a consequence you may 535 | not convey it at all. For example, if you agree to terms that obligate you 536 | to collect a royalty for further conveying from those to whom you convey 537 | the Program, the only way you could satisfy both those terms and this 538 | License would be to refrain entirely from conveying the Program. 539 | 540 | 13. Remote Network Interaction; Use with the GNU General Public License. 541 | 542 | Notwithstanding any other provision of this License, if you modify the 543 | Program, your modified version must prominently offer all users 544 | interacting with it remotely through a computer network (if your version 545 | supports such interaction) an opportunity to receive the Corresponding 546 | Source of your version by providing access to the Corresponding Source 547 | from a network server at no charge, through some standard or customary 548 | means of facilitating copying of software. This Corresponding Source 549 | shall include the Corresponding Source for any work covered by version 3 550 | of the GNU General Public License that is incorporated pursuant to the 551 | following paragraph. 552 | 553 | Notwithstanding any other provision of this License, you have 554 | permission to link or combine any covered work with a work licensed 555 | under version 3 of the GNU General Public License into a single 556 | combined work, and to convey the resulting work. The terms of this 557 | License will continue to apply to the part which is the covered work, 558 | but the work with which it is combined will remain governed by version 559 | 3 of the GNU General Public License. 560 | 561 | 14. Revised Versions of this License. 562 | 563 | The Free Software Foundation may publish revised and/or new versions of 564 | the GNU Affero General Public License from time to time. Such new versions 565 | will be similar in spirit to the present version, but may differ in detail to 566 | address new problems or concerns. 567 | 568 | Each version is given a distinguishing version number. If the 569 | Program specifies that a certain numbered version of the GNU Affero General 570 | Public License "or any later version" applies to it, you have the 571 | option of following the terms and conditions either of that numbered 572 | version or of any later version published by the Free Software 573 | Foundation. If the Program does not specify a version number of the 574 | GNU Affero General Public License, you may choose any version ever published 575 | by the Free Software Foundation. 576 | 577 | If the Program specifies that a proxy can decide which future 578 | versions of the GNU Affero General Public License can be used, that proxy's 579 | public statement of acceptance of a version permanently authorizes you 580 | to choose that version for the Program. 581 | 582 | Later license versions may give you additional or different 583 | permissions. However, no additional obligations are imposed on any 584 | author or copyright holder as a result of your choosing to follow a 585 | later version. 586 | 587 | 15. Disclaimer of Warranty. 588 | 589 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 590 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 591 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 592 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 593 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 594 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 595 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 596 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 597 | 598 | 16. Limitation of Liability. 599 | 600 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 601 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 602 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 603 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 604 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 605 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 606 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 607 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 608 | SUCH DAMAGES. 609 | 610 | 17. Interpretation of Sections 15 and 16. 611 | 612 | If the disclaimer of warranty and limitation of liability provided 613 | above cannot be given local legal effect according to their terms, 614 | reviewing courts shall apply local law that most closely approximates 615 | an absolute waiver of all civil liability in connection with the 616 | Program, unless a warranty or assumption of liability accompanies a 617 | copy of the Program in return for a fee. 618 | 619 | END OF TERMS AND CONDITIONS 620 | 621 | How to Apply These Terms to Your New Programs 622 | 623 | If you develop a new program, and you want it to be of the greatest 624 | possible use to the public, the best way to achieve this is to make it 625 | free software which everyone can redistribute and change under these terms. 626 | 627 | To do so, attach the following notices to the program. It is safest 628 | to attach them to the start of each source file to most effectively 629 | state the exclusion of warranty; and each file should have at least 630 | the "copyright" line and a pointer to where the full notice is found. 631 | 632 | 633 | Copyright (C) 634 | 635 | This program is free software: you can redistribute it and/or modify 636 | it under the terms of the GNU Affero General Public License as published by 637 | the Free Software Foundation, either version 3 of the License, or 638 | (at your option) any later version. 639 | 640 | This program is distributed in the hope that it will be useful, 641 | but WITHOUT ANY WARRANTY; without even the implied warranty of 642 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 643 | GNU Affero General Public License for more details. 644 | 645 | You should have received a copy of the GNU Affero General Public License 646 | along with this program. If not, see . 647 | 648 | Also add information on how to contact you by electronic and paper mail. 649 | 650 | If your software can interact with users remotely through a computer 651 | network, you should also make sure that it provides a way for users to 652 | get its source. For example, if your program is a web application, its 653 | interface could display a "Source" link that leads users to an archive 654 | of the code. There are many ways you could offer source, and different 655 | solutions will be better for different programs; see section 13 for the 656 | specific requirements. 657 | 658 | You should also get your employer (if you work as a programmer) or school, 659 | if any, to sign a "copyright disclaimer" for the program, if necessary. 660 | For more information on this, and how to apply and follow the GNU AGPL, see 661 | . 662 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Obiwan - TFTP Server for PXE Boot 2 | 3 | [![stability-experimental](https://img.shields.io/badge/stability-experimental-orange.svg)](https://github.com/emersion/stability-badges#experimental) 4 | ![GitHub](https://img.shields.io/github/license/blitz/obiwan.svg) 5 | 6 | ## Introduction 🚀 7 | 8 | Obiwan is a TFTP server engineered specifically for PXE Boot 9 | environments. It is designed to serve as a modern and secure 10 | replacement for legacy TFTP server implementations written in C. With 11 | a focus on security, performance, and simplicity, Obiwan integrates 12 | the powerful and memory-safe Rust language with the high-performance 13 | asynchronous capabilities of the Tokio library. 14 | 15 | ## Features 🌟 16 | 17 | - **Read-Only**: Obiwan's mantra is safety. Tailored for PXE boot 18 | environments, it exclusively supports reading files to eliminate 19 | potential security loopholes and misconfigurations. 20 | 21 | - **Security-First**: Obiwan takes advantage of Rust's memory safety 22 | and its minimalist design to substantially shrink the attack 23 | surface. 24 | 25 | - **OK Performance**: While staying simple, leveraging Tokio's 26 | asynchronous capabilities, Obiwan handles a plethora of concurrent 27 | file requests effortlessly. 28 | 29 | - **No Configuration**: With sensible defaults, you just point it at a 30 | directory and off you go. 31 | 32 | - **Free Software**: Obiwan thrives with your support and is open for 33 | contributions! 34 | 35 | ## Tested Clients 36 | 37 | These clients are checked via CI: 38 | 39 | - [atftp](https://sourceforge.net/projects/atftp/) 40 | - [tftp-hpa / in.tftp](https://mirrors.edge.kernel.org/pub/software/network/tftp/tftp-hpa/) 41 | 42 | The following clients have been reported to work: 43 | 44 | - Lenovo ThinkStation P360 UEFI 45 | - [iPXE](https://ipxe.org/) 46 | 47 | Feel free to open a PR to add to these lists! 48 | 49 | ## Contributing 50 | 51 | Obiwan is currently experimental and is missing features and 52 | testing. Most welcome are contributions that improve documentation, 53 | increase test coverage, or implement missing TFTP extensions. Security 54 | improvements, such as reducing the number of dependencies or improving 55 | sandboxing are also highly welcome. Performance improvements, such as 56 | removing memory allocations, are also welcome as long as they don't 57 | complicate the code base. 58 | 59 | Obiwan will never support writing files. Please do not try to add this 60 | feature. 61 | 62 | ## Getting Started 🏁 63 | 64 | ### NixOS 65 | 66 | This documentation assumes that your [NixOS](https://nixos.org/) 67 | system is built as a [Nix Flake](https://nixos.wiki/wiki/Flakes). 68 | 69 | In your `flake.nix`, add Obiwan as an input and enable the module in 70 | a NixOS configuration: 71 | 72 | ```nix 73 | { 74 | # ... 75 | 76 | inputs = { 77 | # ... other inputs ... 78 | 79 | obiwan = { 80 | url = "github:blitz/obiwan"; 81 | 82 | # Optional to reduce the system closure. May not work 83 | # inputs.nixpkgs.follows = "nixpkgs"; 84 | }; 85 | }; 86 | 87 | outputs = { self, nixpkgs, obiwan ... }: { 88 | nixosConfigurations.machine = nixpkgs.lib.nixosSystem { 89 | system = "x86_64-linux"; 90 | modules = [ 91 | # ... other modules ... 92 | 93 | obiwan.nixosModules.default 94 | 95 | ./machine.nix 96 | ]; 97 | }; 98 | }; 99 | } 100 | ``` 101 | 102 | You can then enable Obiwan by adding the following configuration in 103 | `machine.nix`: 104 | 105 | ```nix 106 | { config, pkgs, lib, ... }: { 107 | # ... other configuration ... 108 | 109 | services.obiwan = { 110 | enable = true; 111 | 112 | # The directory that will be made available via TFTP. Must exist or the 113 | # service will fail to start. 114 | root = "/srv/tftp"; 115 | 116 | # The IP the service will listen on. 117 | listenAddress = "192.168.1.1"; 118 | }; 119 | } 120 | ``` 121 | 122 | Check `nix/module.nix` in this repository for other configuration 123 | options. 124 | 125 | ### Other Linux 126 | 127 | Obiwan is a Rust application without special dependencies. With a 128 | recent Rust toolchain, you can build and install it with `cargo`: 129 | 130 | ```console 131 | $ cd ws/obiwan 132 | 133 | # Check that all unit tests pass. 134 | $ cargo test 135 | 136 | # Build the release version. 137 | $ cargo build --release 138 | 139 | # Install it into $HOME/.cargo/bin 140 | $ cargo install --path . 141 | ``` 142 | 143 | To run Obiwan as a systemd unit, you can take inspiration from 144 | `nix/module.nix`. See `systemd.services.obiwan` for the NixOS systemd 145 | unit description, which should be a good starting point for any other 146 | Linux. 147 | 148 | ## Support 149 | 150 | Should you encounter any issues or have questions, please open an 151 | issue on GitHub. 152 | -------------------------------------------------------------------------------- /flake.lock: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": { 3 | "advisory-db": { 4 | "flake": false, 5 | "locked": { 6 | "lastModified": 1702652226, 7 | "narHash": "sha256-nBq7EmP7E42XRLkMArk4aSjoclBxFT2gxgLmS2xF1EY=", 8 | "owner": "rustsec", 9 | "repo": "advisory-db", 10 | "rev": "fd71859263a51bf69da4ad9f692d6ebfe7db525b", 11 | "type": "github" 12 | }, 13 | "original": { 14 | "owner": "rustsec", 15 | "repo": "advisory-db", 16 | "type": "github" 17 | } 18 | }, 19 | "crane": { 20 | "inputs": { 21 | "nixpkgs": [ 22 | "nixpkgs" 23 | ] 24 | }, 25 | "locked": { 26 | "lastModified": 1702749801, 27 | "narHash": "sha256-frIhfv0h4RAobzQ/vp7C7a2bEbz2gcZc2qVSc2CElxw=", 28 | "owner": "ipetkov", 29 | "repo": "crane", 30 | "rev": "3330c0de31e8729bb5d01820e59ceb1640e128dc", 31 | "type": "github" 32 | }, 33 | "original": { 34 | "owner": "ipetkov", 35 | "repo": "crane", 36 | "type": "github" 37 | } 38 | }, 39 | "flake-compat": { 40 | "flake": false, 41 | "locked": { 42 | "lastModified": 1696426674, 43 | "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", 44 | "owner": "edolstra", 45 | "repo": "flake-compat", 46 | "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", 47 | "type": "github" 48 | }, 49 | "original": { 50 | "owner": "edolstra", 51 | "repo": "flake-compat", 52 | "type": "github" 53 | } 54 | }, 55 | "flake-parts": { 56 | "inputs": { 57 | "nixpkgs-lib": [ 58 | "nixpkgs" 59 | ] 60 | }, 61 | "locked": { 62 | "lastModified": 1701473968, 63 | "narHash": "sha256-YcVE5emp1qQ8ieHUnxt1wCZCC3ZfAS+SRRWZ2TMda7E=", 64 | "owner": "hercules-ci", 65 | "repo": "flake-parts", 66 | "rev": "34fed993f1674c8d06d58b37ce1e0fe5eebcb9f5", 67 | "type": "github" 68 | }, 69 | "original": { 70 | "owner": "hercules-ci", 71 | "repo": "flake-parts", 72 | "type": "github" 73 | } 74 | }, 75 | "flake-utils": { 76 | "inputs": { 77 | "systems": "systems" 78 | }, 79 | "locked": { 80 | "lastModified": 1701680307, 81 | "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=", 82 | "owner": "numtide", 83 | "repo": "flake-utils", 84 | "rev": "4022d587cbbfd70fe950c1e2083a02621806a725", 85 | "type": "github" 86 | }, 87 | "original": { 88 | "owner": "numtide", 89 | "repo": "flake-utils", 90 | "type": "github" 91 | } 92 | }, 93 | "gitignore": { 94 | "inputs": { 95 | "nixpkgs": [ 96 | "pre-commit-hooks-nix", 97 | "nixpkgs" 98 | ] 99 | }, 100 | "locked": { 101 | "lastModified": 1660459072, 102 | "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=", 103 | "owner": "hercules-ci", 104 | "repo": "gitignore.nix", 105 | "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73", 106 | "type": "github" 107 | }, 108 | "original": { 109 | "owner": "hercules-ci", 110 | "repo": "gitignore.nix", 111 | "type": "github" 112 | } 113 | }, 114 | "nixpkgs": { 115 | "locked": { 116 | "lastModified": 1702723167, 117 | "narHash": "sha256-cIxAF4Do+B7mQxzRDo/8B9QO0i2ap3i/i6Ujk8kx+Ws=", 118 | "owner": "NixOS", 119 | "repo": "nixpkgs", 120 | "rev": "7d6929828a2d28eda9d37254ff6be3b6819506ca", 121 | "type": "github" 122 | }, 123 | "original": { 124 | "owner": "NixOS", 125 | "ref": "nixos-unstable-small", 126 | "repo": "nixpkgs", 127 | "type": "github" 128 | } 129 | }, 130 | "nixpkgs-stable": { 131 | "locked": { 132 | "lastModified": 1685801374, 133 | "narHash": "sha256-otaSUoFEMM+LjBI1XL/xGB5ao6IwnZOXc47qhIgJe8U=", 134 | "owner": "NixOS", 135 | "repo": "nixpkgs", 136 | "rev": "c37ca420157f4abc31e26f436c1145f8951ff373", 137 | "type": "github" 138 | }, 139 | "original": { 140 | "owner": "NixOS", 141 | "ref": "nixos-23.05", 142 | "repo": "nixpkgs", 143 | "type": "github" 144 | } 145 | }, 146 | "pre-commit-hooks-nix": { 147 | "inputs": { 148 | "flake-compat": [ 149 | "flake-compat" 150 | ], 151 | "flake-utils": [ 152 | "flake-utils" 153 | ], 154 | "gitignore": "gitignore", 155 | "nixpkgs": [ 156 | "nixpkgs" 157 | ], 158 | "nixpkgs-stable": "nixpkgs-stable" 159 | }, 160 | "locked": { 161 | "lastModified": 1702456155, 162 | "narHash": "sha256-I2XhXGAecdGlqi6hPWYT83AQtMgL+aa3ulA85RAEgOk=", 163 | "owner": "cachix", 164 | "repo": "pre-commit-hooks.nix", 165 | "rev": "007a45d064c1c32d04e1b8a0de5ef00984c419bc", 166 | "type": "github" 167 | }, 168 | "original": { 169 | "owner": "cachix", 170 | "repo": "pre-commit-hooks.nix", 171 | "type": "github" 172 | } 173 | }, 174 | "root": { 175 | "inputs": { 176 | "advisory-db": "advisory-db", 177 | "crane": "crane", 178 | "flake-compat": "flake-compat", 179 | "flake-parts": "flake-parts", 180 | "flake-utils": "flake-utils", 181 | "nixpkgs": "nixpkgs", 182 | "pre-commit-hooks-nix": "pre-commit-hooks-nix" 183 | } 184 | }, 185 | "systems": { 186 | "locked": { 187 | "lastModified": 1681028828, 188 | "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", 189 | "owner": "nix-systems", 190 | "repo": "default", 191 | "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", 192 | "type": "github" 193 | }, 194 | "original": { 195 | "owner": "nix-systems", 196 | "repo": "default", 197 | "type": "github" 198 | } 199 | } 200 | }, 201 | "root": "root", 202 | "version": 7 203 | } 204 | -------------------------------------------------------------------------------- /flake.nix: -------------------------------------------------------------------------------- 1 | { 2 | description = "Obiwan TFTP Server"; 3 | 4 | inputs = { 5 | nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable-small"; 6 | 7 | flake-utils.url = "github:numtide/flake-utils"; 8 | 9 | flake-compat = { 10 | url = "github:edolstra/flake-compat"; 11 | flake = false; 12 | }; 13 | 14 | flake-parts = { 15 | url = "github:hercules-ci/flake-parts"; 16 | inputs.nixpkgs-lib.follows = "nixpkgs"; 17 | }; 18 | 19 | pre-commit-hooks-nix = { 20 | url = "github:cachix/pre-commit-hooks.nix"; 21 | inputs.nixpkgs.follows = "nixpkgs"; 22 | inputs.flake-utils.follows = "flake-utils"; 23 | inputs.flake-compat.follows = "flake-compat"; 24 | }; 25 | 26 | crane = { 27 | url = "github:ipetkov/crane"; 28 | inputs.nixpkgs.follows = "nixpkgs"; 29 | inputs.flake-utils.follows = "flake-utils"; 30 | inputs.flake-compat.follows = "flake-compat"; 31 | }; 32 | 33 | advisory-db = { 34 | url = "github:rustsec/advisory-db"; 35 | flake = false; 36 | }; 37 | }; 38 | 39 | outputs = inputs@{ self, crane, flake-parts, advisory-db, ... }: 40 | flake-parts.lib.mkFlake { inherit inputs; } ({ moduleWithSystem, ... }: { 41 | imports = [ 42 | # Formatting and quality checks. 43 | inputs.pre-commit-hooks-nix.flakeModule 44 | ]; 45 | 46 | systems = [ 47 | "x86_64-linux" 48 | "aarch64-linux" 49 | ]; 50 | 51 | flake.nixosModules.default = moduleWithSystem ( 52 | perSystem@{ config }: 53 | { ... }: { 54 | imports = [ 55 | ./nix/module.nix 56 | ]; 57 | 58 | services.obiwan.package = perSystem.config.packages.default; 59 | } 60 | ); 61 | 62 | perSystem = { config, system, pkgs, lib, ... }: 63 | let 64 | craneLib = crane.lib.${system}; 65 | src = craneLib.cleanCargoSource (craneLib.path ./ws); 66 | 67 | # Common arguments can be set here to avoid repeating them later 68 | commonArgs = { 69 | pname = "obiwan"; 70 | 71 | inherit src; 72 | }; 73 | 74 | # Build *just* the cargo dependencies, so we can reuse all 75 | # of that work (e.g. via cachix) when running in CI. 76 | cargoArtifacts = craneLib.buildDepsOnly commonArgs; 77 | 78 | # Build the actual crate itself, reusing the dependency 79 | # artifacts from above. 80 | obiwan = craneLib.buildPackage (commonArgs // { 81 | inherit cargoArtifacts; 82 | }); 83 | in 84 | { 85 | pre-commit.settings.hooks = { 86 | nixpkgs-fmt.enable = true; 87 | typos.enable = true; 88 | deadnix.enable = true; 89 | markdownlint.enable = true; 90 | }; 91 | 92 | # Only run integration tests on x86. The aarch64 runners 93 | # don't have KVM and the tests take too long. 94 | checks = lib.optionalAttrs (system == "x86_64-linux") 95 | (import ./nix/tests { 96 | inherit pkgs; 97 | module = self.nixosModules.default; 98 | }) // { 99 | # Build the crate as part of `nix flake check` for convenience 100 | inherit obiwan; 101 | 102 | # Run clippy (and deny all warnings) on the crate source, 103 | # again, resuing the dependency artifacts from above. 104 | # 105 | # Note that this is done as a separate derivation so that 106 | # we can block the CI if there are issues here, but not 107 | # prevent downstream consumers from building our crate by itself. 108 | obiwan-clippy = craneLib.cargoClippy (commonArgs // { 109 | inherit cargoArtifacts; 110 | cargoClippyExtraArgs = "--all-targets -- --deny warnings"; 111 | }); 112 | 113 | # Audit dependencies 114 | obiwan-audit = craneLib.cargoAudit { 115 | inherit src advisory-db; 116 | }; 117 | }; 118 | 119 | packages = { 120 | default = obiwan; 121 | }; 122 | 123 | devShells.default = pkgs.mkShell { 124 | shellHook = '' 125 | ${config.pre-commit.installationScript} 126 | ''; 127 | 128 | inputsFrom = [ 129 | config.packages.default 130 | ]; 131 | }; 132 | }; 133 | }); 134 | } 135 | -------------------------------------------------------------------------------- /nix/module.nix: -------------------------------------------------------------------------------- 1 | { lib, config, pkgs, ... }: 2 | with lib; 3 | let 4 | cfg = config.services.obiwan; 5 | in 6 | { 7 | options.services.obiwan = { 8 | enable = mkEnableOption "Obiwan TFTP server"; 9 | 10 | package = mkOption { 11 | type = types.package; 12 | default = pkgs.obiwan; 13 | description = "Obiwan TFTP server package"; 14 | }; 15 | 16 | root = mkOption { 17 | default = "/srv/tftp"; 18 | type = types.path; 19 | description = "The directory that will be shared via TFTP"; 20 | }; 21 | 22 | openFirewall = mkOption { 23 | default = false; 24 | type = types.bool; 25 | description = "Open firewall ports"; 26 | }; 27 | 28 | listenAddress = mkOption { 29 | description = "Listen on this IP"; 30 | default = "127.0.0.1"; 31 | type = types.str; 32 | }; 33 | 34 | listenPort = mkOption { 35 | description = "Listen on this port"; 36 | default = 69; 37 | type = types.int; 38 | }; 39 | 40 | extraOptions = mkOption { 41 | description = "Additional command-line arguments to obiwan"; 42 | default = [ ]; 43 | type = types.listOf types.str; 44 | }; 45 | }; 46 | 47 | config = mkIf cfg.enable { 48 | 49 | networking.firewall.allowedUDPPorts = mkIf cfg.openFirewall [ cfg.listenPort ]; 50 | 51 | systemd.services.obiwan = { 52 | description = "Obiwan TFTP Server"; 53 | after = [ "network.target" ]; 54 | wantedBy = [ "multi-user.target" ]; 55 | 56 | # This is currently not compatible with DynamicUser. 57 | # 58 | # confinement = { 59 | # enable = true; 60 | # binSh = null; 61 | # }; 62 | 63 | serviceConfig = { 64 | ExecStart = "${cfg.package}/bin/obiwan -l '${cfg.listenAddress}:${toString cfg.listenPort}' '${cfg.root}' ${lib.concatStringsSep " " cfg.extraOptions}"; 65 | 66 | # It would be nice if we could use this. Prevents us from 67 | # binding to the server port. 68 | # 69 | # DynamicUser = true; 70 | 71 | # Obiwan does this on its own, but it can't hurt. 72 | NoNewPrivileges = true; 73 | 74 | RestrictAddressFamilies = [ "AF_INET" "AF_INET6" ]; 75 | 76 | # These prevent binding to the server port. 77 | # 78 | # PrivateDevices = true; 79 | # PrivateUsers = true; 80 | 81 | ProtectClock = true; 82 | ProtectHostname = true; 83 | PrivateTmp = true; 84 | 85 | # Mount everything read-only except /dev, /proc, /sys. 86 | ProtectSystem = "strict"; 87 | 88 | ProtectControlGroups = true; 89 | ProtectKernelLogs = true; 90 | ProtectKernelModules = true; 91 | ProtectKernelTunables = true; 92 | SystemCallArchitectures = "native"; 93 | MemoryDenyWriteExecute = true; 94 | RestrictRealtime = true; 95 | LockPersonality = true; 96 | RestrictSUIDSGID = true; 97 | RestrictNamespaces = true; 98 | ProcSubset = "pid"; 99 | ProtectProc = "invisible"; 100 | UMask = "077"; 101 | 102 | SystemCallFilter = [ 103 | "~@clock" 104 | "~@cpu-emulation" 105 | "~@debug" 106 | "~@module" 107 | "~@obsolete" 108 | "~@raw-io" 109 | "~@reboot" 110 | "~@resources" 111 | "~@swap" 112 | "~@sync" 113 | ]; 114 | 115 | CapabilityBoundingSet = [ 116 | "~CAP_AUDIT_CONTROL" 117 | "~CAP_AUDIT_READ" 118 | "~CAP_AUDIT_WRITE" 119 | "~CAP_BLOCK_SUSPEND" 120 | "~CAP_CHOWN" 121 | "~CAP_FSETID" 122 | "~CAP_IPC_LOCK" 123 | "~CAP_KILL" 124 | "~CAP_LEASE" 125 | "~CAP_LINUX_IMMUTABLE" 126 | "~CAP_MAC_ADMIN" 127 | "~CAP_MAC_OVERRIDE" 128 | "~CAP_MKNOD" 129 | "~CAP_NET_ADMIN" 130 | "~CAP_NET_RAW" 131 | "~CAP_SETFCAP" 132 | "~CAP_SYSLOG" 133 | "~CAP_SYS_ADMIN" 134 | "~CAP_SYS_BOOT" 135 | "~CAP_SYS_NICE" 136 | "~CAP_SYS_PACCT" 137 | "~CAP_SYS_PTRACE" 138 | "~CAP_SYS_RAWIO" 139 | "~CAP_SYS_RESOURCE" 140 | "~CAP_SYS_TTY_CONFIG" 141 | ]; 142 | 143 | # Instead of the above, I would rather build an allow-list that includes: 144 | # 145 | # - CAP_SYS_CHROOT 146 | # - CAP_SET_UID 147 | # - CAP_NET_BIND_SERVICE 148 | # 149 | # and start obiwan as an unprivileged user. But this only 150 | # works with NoNewPrivileges=false and this is incompatible 151 | # with many sandboxing features above. 152 | # 153 | # So we are stuck with letting obiwan drop root. 154 | }; 155 | }; 156 | }; 157 | } 158 | -------------------------------------------------------------------------------- /nix/tests/can-fetch-files.nix: -------------------------------------------------------------------------------- 1 | { pkgs, module }: 2 | pkgs.nixosTest { 3 | name = "can-fetch-files"; 4 | 5 | nodes.server = { pkgs, ... }: { 6 | imports = [ 7 | module 8 | ]; 9 | 10 | services.obiwan = 11 | let 12 | obiwanRoot = pkgs.runCommand "obiwan-root" 13 | { 14 | nativeBuildInputs = [ 15 | pkgs.openssl 16 | ]; 17 | 18 | # Make this a fixed-output derivation so we don't 19 | # needlessly rebuild it when the dependencies change. 20 | outputHashMode = "recursive"; 21 | outputHashAlgo = "sha256"; 22 | outputHash = "hCGMglO04jUrrXm8oH0klSpHZgK20WJI44UDerkquDY="; 23 | } '' 24 | mkdir -p $out 25 | 26 | # We want reproducible "random" files (at least not just zeroes). 27 | head -c 1M /dev/zero | openssl enc -pbkdf2 -aes-128-ctr -nosalt -pass pass:12345 > $out/smallfile 28 | 29 | # We need a file that is larger than the typical block size (~1500 bytes) and has more blocks 30 | # than fits in 2^16. 31 | head -c 150M /dev/zero | openssl enc -pbkdf2 -aes-128-ctr -nosalt -pass pass:12345 > $out/largefile 32 | 33 | ( cd $out ; sha256sum smallfile largefile > SHA256SUMS ) 34 | ''; 35 | in 36 | { 37 | enable = true; 38 | 39 | listenAddress = "0.0.0.0"; 40 | openFirewall = true; 41 | 42 | root = "${obiwanRoot}"; 43 | 44 | extraOptions = [ "-v" ]; 45 | }; 46 | }; 47 | 48 | nodes.client = { pkgs, ... }: { 49 | 50 | # The TFTP server will send us packets on a new UDP port. 51 | networking.firewall.enable = false; 52 | 53 | environment.systemPackages = [ 54 | pkgs.inetutils # tftp 55 | pkgs.atftp 56 | ]; 57 | }; 58 | 59 | testScript = '' 60 | server.start() 61 | server.wait_for_unit("network-online.target", timeout = 120) 62 | server.wait_for_unit("obiwan.service") 63 | 64 | # We want to be a good sandboxing example. 65 | server.succeed("systemd-analyze security | grep -q 'obiwan.* OK'") 66 | 67 | client.start() 68 | client.wait_for_unit("network-online.target", timeout = 120) 69 | 70 | with subtest("in.tftp can fetch files"): 71 | client.succeed("echo get SHA256SUMS | tftp server", timeout = 120) 72 | client.succeed("( echo binary ; echo get smallfile ) | tftp server", timeout = 120) 73 | 74 | # This consistently fails and it doesn't look like it's our problem. 75 | # client.succeed("( echo binary ; echo get largefile ) | tftp server", timeout = 600) 76 | 77 | print(client.succeed("grep -v largefile SHA256SUMS | sha256sum --check")) 78 | 79 | with subtest("atftp can fetch files"): 80 | client.succeed("rm -f SHA256SUMS smallfile largefile") 81 | client.succeed("atftp -g -r SHA256SUMS server", timeout = 120) 82 | client.succeed("atftp -g -r smallfile server", timeout = 120) 83 | client.succeed("atftp -g -r largefile server", timeout = 600) 84 | client.succeed("sha256sum --check SHA256SUMS") 85 | 86 | with subtest("atftp can fetch files with big block size"): 87 | client.succeed("rm -f SHA256SUMS smallfile largefile") 88 | client.succeed("atftp --option 'blksize 1400' -g -r SHA256SUMS server", timeout = 120) 89 | client.succeed("atftp --option 'blksize 1400' -g -r smallfile server", timeout = 120) 90 | client.succeed("atftp --option 'blksize 1400' -g -r largefile server", timeout = 600) 91 | client.succeed("sha256sum --check SHA256SUMS") 92 | 93 | ''; 94 | } 95 | -------------------------------------------------------------------------------- /nix/tests/default.nix: -------------------------------------------------------------------------------- 1 | { pkgs, module }: 2 | { 3 | canFetchFiles = import ./can-fetch-files.nix { inherit pkgs module; }; 4 | } 5 | -------------------------------------------------------------------------------- /ws/Cargo.lock: -------------------------------------------------------------------------------- 1 | # This file is automatically @generated by Cargo. 2 | # It is not intended for manual editing. 3 | version = 3 4 | 5 | [[package]] 6 | name = "addr2line" 7 | version = "0.21.0" 8 | source = "registry+https://github.com/rust-lang/crates.io-index" 9 | checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" 10 | dependencies = [ 11 | "gimli", 12 | ] 13 | 14 | [[package]] 15 | name = "adler" 16 | version = "1.0.2" 17 | source = "registry+https://github.com/rust-lang/crates.io-index" 18 | checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" 19 | 20 | [[package]] 21 | name = "anstyle" 22 | version = "1.0.8" 23 | source = "registry+https://github.com/rust-lang/crates.io-index" 24 | checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1" 25 | 26 | [[package]] 27 | name = "anyhow" 28 | version = "1.0.93" 29 | source = "registry+https://github.com/rust-lang/crates.io-index" 30 | checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775" 31 | 32 | [[package]] 33 | name = "array-init" 34 | version = "2.1.0" 35 | source = "registry+https://github.com/rust-lang/crates.io-index" 36 | checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc" 37 | 38 | [[package]] 39 | name = "async-trait" 40 | version = "0.1.83" 41 | source = "registry+https://github.com/rust-lang/crates.io-index" 42 | checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd" 43 | dependencies = [ 44 | "proc-macro2", 45 | "quote", 46 | "syn 2.0.48", 47 | ] 48 | 49 | [[package]] 50 | name = "backtrace" 51 | version = "0.3.69" 52 | source = "registry+https://github.com/rust-lang/crates.io-index" 53 | checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" 54 | dependencies = [ 55 | "addr2line", 56 | "cc", 57 | "cfg-if", 58 | "libc", 59 | "miniz_oxide", 60 | "object", 61 | "rustc-demangle", 62 | ] 63 | 64 | [[package]] 65 | name = "binrw" 66 | version = "0.14.1" 67 | source = "registry+https://github.com/rust-lang/crates.io-index" 68 | checksum = "7d4bca59c20d6f40c2cc0802afbe1e788b89096f61bdf7aeea6bf00f10c2909b" 69 | dependencies = [ 70 | "array-init", 71 | "binrw_derive", 72 | "bytemuck", 73 | ] 74 | 75 | [[package]] 76 | name = "binrw_derive" 77 | version = "0.14.1" 78 | source = "registry+https://github.com/rust-lang/crates.io-index" 79 | checksum = "d8ba42866ce5bced2645bfa15e97eef2c62d2bdb530510538de8dd3d04efff3c" 80 | dependencies = [ 81 | "either", 82 | "owo-colors", 83 | "proc-macro2", 84 | "quote", 85 | "syn 1.0.109", 86 | ] 87 | 88 | [[package]] 89 | name = "bitflags" 90 | version = "2.4.1" 91 | source = "registry+https://github.com/rust-lang/crates.io-index" 92 | checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" 93 | 94 | [[package]] 95 | name = "bytemuck" 96 | version = "1.14.0" 97 | source = "registry+https://github.com/rust-lang/crates.io-index" 98 | checksum = "374d28ec25809ee0e23827c2ab573d729e293f281dfe393500e7ad618baa61c6" 99 | 100 | [[package]] 101 | name = "bytes" 102 | version = "1.5.0" 103 | source = "registry+https://github.com/rust-lang/crates.io-index" 104 | checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" 105 | 106 | [[package]] 107 | name = "cc" 108 | version = "1.0.83" 109 | source = "registry+https://github.com/rust-lang/crates.io-index" 110 | checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" 111 | dependencies = [ 112 | "libc", 113 | ] 114 | 115 | [[package]] 116 | name = "cfg-if" 117 | version = "1.0.0" 118 | source = "registry+https://github.com/rust-lang/crates.io-index" 119 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" 120 | 121 | [[package]] 122 | name = "cfg_aliases" 123 | version = "0.2.1" 124 | source = "registry+https://github.com/rust-lang/crates.io-index" 125 | checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" 126 | 127 | [[package]] 128 | name = "clap" 129 | version = "4.5.21" 130 | source = "registry+https://github.com/rust-lang/crates.io-index" 131 | checksum = "fb3b4b9e5a7c7514dfa52869339ee98b3156b0bfb4e8a77c4ff4babb64b1604f" 132 | dependencies = [ 133 | "clap_builder", 134 | "clap_derive", 135 | ] 136 | 137 | [[package]] 138 | name = "clap_builder" 139 | version = "4.5.21" 140 | source = "registry+https://github.com/rust-lang/crates.io-index" 141 | checksum = "b17a95aa67cc7b5ebd32aa5370189aa0d79069ef1c64ce893bd30fb24bff20ec" 142 | dependencies = [ 143 | "anstyle", 144 | "clap_lex", 145 | ] 146 | 147 | [[package]] 148 | name = "clap_derive" 149 | version = "4.5.18" 150 | source = "registry+https://github.com/rust-lang/crates.io-index" 151 | checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab" 152 | dependencies = [ 153 | "heck", 154 | "proc-macro2", 155 | "quote", 156 | "syn 2.0.48", 157 | ] 158 | 159 | [[package]] 160 | name = "clap_lex" 161 | version = "0.7.0" 162 | source = "registry+https://github.com/rust-lang/crates.io-index" 163 | checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce" 164 | 165 | [[package]] 166 | name = "deranged" 167 | version = "0.3.10" 168 | source = "registry+https://github.com/rust-lang/crates.io-index" 169 | checksum = "8eb30d70a07a3b04884d2677f06bec33509dc67ca60d92949e5535352d3191dc" 170 | dependencies = [ 171 | "powerfmt", 172 | ] 173 | 174 | [[package]] 175 | name = "either" 176 | version = "1.9.0" 177 | source = "registry+https://github.com/rust-lang/crates.io-index" 178 | checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" 179 | 180 | [[package]] 181 | name = "gimli" 182 | version = "0.28.1" 183 | source = "registry+https://github.com/rust-lang/crates.io-index" 184 | checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" 185 | 186 | [[package]] 187 | name = "heck" 188 | version = "0.5.0" 189 | source = "registry+https://github.com/rust-lang/crates.io-index" 190 | checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" 191 | 192 | [[package]] 193 | name = "hermit-abi" 194 | version = "0.3.9" 195 | source = "registry+https://github.com/rust-lang/crates.io-index" 196 | checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" 197 | 198 | [[package]] 199 | name = "itoa" 200 | version = "1.0.10" 201 | source = "registry+https://github.com/rust-lang/crates.io-index" 202 | checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" 203 | 204 | [[package]] 205 | name = "libc" 206 | version = "0.2.155" 207 | source = "registry+https://github.com/rust-lang/crates.io-index" 208 | checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" 209 | 210 | [[package]] 211 | name = "log" 212 | version = "0.4.22" 213 | source = "registry+https://github.com/rust-lang/crates.io-index" 214 | checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" 215 | 216 | [[package]] 217 | name = "memchr" 218 | version = "2.6.4" 219 | source = "registry+https://github.com/rust-lang/crates.io-index" 220 | checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" 221 | 222 | [[package]] 223 | name = "miniz_oxide" 224 | version = "0.7.1" 225 | source = "registry+https://github.com/rust-lang/crates.io-index" 226 | checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" 227 | dependencies = [ 228 | "adler", 229 | ] 230 | 231 | [[package]] 232 | name = "mio" 233 | version = "1.0.1" 234 | source = "registry+https://github.com/rust-lang/crates.io-index" 235 | checksum = "4569e456d394deccd22ce1c1913e6ea0e54519f577285001215d33557431afe4" 236 | dependencies = [ 237 | "hermit-abi", 238 | "libc", 239 | "wasi", 240 | "windows-sys 0.52.0", 241 | ] 242 | 243 | [[package]] 244 | name = "nix" 245 | version = "0.29.0" 246 | source = "registry+https://github.com/rust-lang/crates.io-index" 247 | checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46" 248 | dependencies = [ 249 | "bitflags", 250 | "cfg-if", 251 | "cfg_aliases", 252 | "libc", 253 | ] 254 | 255 | [[package]] 256 | name = "obiwan" 257 | version = "0.1.0" 258 | dependencies = [ 259 | "anyhow", 260 | "async-trait", 261 | "binrw", 262 | "clap", 263 | "log", 264 | "nix", 265 | "simplelog", 266 | "tokio", 267 | ] 268 | 269 | [[package]] 270 | name = "object" 271 | version = "0.32.1" 272 | source = "registry+https://github.com/rust-lang/crates.io-index" 273 | checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" 274 | dependencies = [ 275 | "memchr", 276 | ] 277 | 278 | [[package]] 279 | name = "owo-colors" 280 | version = "3.5.0" 281 | source = "registry+https://github.com/rust-lang/crates.io-index" 282 | checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f" 283 | 284 | [[package]] 285 | name = "pin-project-lite" 286 | version = "0.2.13" 287 | source = "registry+https://github.com/rust-lang/crates.io-index" 288 | checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" 289 | 290 | [[package]] 291 | name = "powerfmt" 292 | version = "0.2.0" 293 | source = "registry+https://github.com/rust-lang/crates.io-index" 294 | checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" 295 | 296 | [[package]] 297 | name = "proc-macro2" 298 | version = "1.0.76" 299 | source = "registry+https://github.com/rust-lang/crates.io-index" 300 | checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c" 301 | dependencies = [ 302 | "unicode-ident", 303 | ] 304 | 305 | [[package]] 306 | name = "quote" 307 | version = "1.0.35" 308 | source = "registry+https://github.com/rust-lang/crates.io-index" 309 | checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" 310 | dependencies = [ 311 | "proc-macro2", 312 | ] 313 | 314 | [[package]] 315 | name = "rustc-demangle" 316 | version = "0.1.23" 317 | source = "registry+https://github.com/rust-lang/crates.io-index" 318 | checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76" 319 | 320 | [[package]] 321 | name = "serde" 322 | version = "1.0.193" 323 | source = "registry+https://github.com/rust-lang/crates.io-index" 324 | checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89" 325 | dependencies = [ 326 | "serde_derive", 327 | ] 328 | 329 | [[package]] 330 | name = "serde_derive" 331 | version = "1.0.193" 332 | source = "registry+https://github.com/rust-lang/crates.io-index" 333 | checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" 334 | dependencies = [ 335 | "proc-macro2", 336 | "quote", 337 | "syn 2.0.48", 338 | ] 339 | 340 | [[package]] 341 | name = "simplelog" 342 | version = "0.12.2" 343 | source = "registry+https://github.com/rust-lang/crates.io-index" 344 | checksum = "16257adbfaef1ee58b1363bdc0664c9b8e1e30aed86049635fb5f147d065a9c0" 345 | dependencies = [ 346 | "log", 347 | "time", 348 | ] 349 | 350 | [[package]] 351 | name = "socket2" 352 | version = "0.5.5" 353 | source = "registry+https://github.com/rust-lang/crates.io-index" 354 | checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9" 355 | dependencies = [ 356 | "libc", 357 | "windows-sys 0.48.0", 358 | ] 359 | 360 | [[package]] 361 | name = "syn" 362 | version = "1.0.109" 363 | source = "registry+https://github.com/rust-lang/crates.io-index" 364 | checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" 365 | dependencies = [ 366 | "proc-macro2", 367 | "quote", 368 | "unicode-ident", 369 | ] 370 | 371 | [[package]] 372 | name = "syn" 373 | version = "2.0.48" 374 | source = "registry+https://github.com/rust-lang/crates.io-index" 375 | checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f" 376 | dependencies = [ 377 | "proc-macro2", 378 | "quote", 379 | "unicode-ident", 380 | ] 381 | 382 | [[package]] 383 | name = "time" 384 | version = "0.3.30" 385 | source = "registry+https://github.com/rust-lang/crates.io-index" 386 | checksum = "c4a34ab300f2dee6e562c10a046fc05e358b29f9bf92277f30c3c8d82275f6f5" 387 | dependencies = [ 388 | "deranged", 389 | "itoa", 390 | "powerfmt", 391 | "serde", 392 | "time-core", 393 | "time-macros", 394 | ] 395 | 396 | [[package]] 397 | name = "time-core" 398 | version = "0.1.2" 399 | source = "registry+https://github.com/rust-lang/crates.io-index" 400 | checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" 401 | 402 | [[package]] 403 | name = "time-macros" 404 | version = "0.2.15" 405 | source = "registry+https://github.com/rust-lang/crates.io-index" 406 | checksum = "4ad70d68dba9e1f8aceda7aa6711965dfec1cac869f311a51bd08b3a2ccbce20" 407 | dependencies = [ 408 | "time-core", 409 | ] 410 | 411 | [[package]] 412 | name = "tokio" 413 | version = "1.41.1" 414 | source = "registry+https://github.com/rust-lang/crates.io-index" 415 | checksum = "22cfb5bee7a6a52939ca9224d6ac897bb669134078daa8735560897f69de4d33" 416 | dependencies = [ 417 | "backtrace", 418 | "bytes", 419 | "libc", 420 | "mio", 421 | "pin-project-lite", 422 | "socket2", 423 | "tokio-macros", 424 | "windows-sys 0.52.0", 425 | ] 426 | 427 | [[package]] 428 | name = "tokio-macros" 429 | version = "2.4.0" 430 | source = "registry+https://github.com/rust-lang/crates.io-index" 431 | checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752" 432 | dependencies = [ 433 | "proc-macro2", 434 | "quote", 435 | "syn 2.0.48", 436 | ] 437 | 438 | [[package]] 439 | name = "unicode-ident" 440 | version = "1.0.12" 441 | source = "registry+https://github.com/rust-lang/crates.io-index" 442 | checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" 443 | 444 | [[package]] 445 | name = "wasi" 446 | version = "0.11.0+wasi-snapshot-preview1" 447 | source = "registry+https://github.com/rust-lang/crates.io-index" 448 | checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" 449 | 450 | [[package]] 451 | name = "windows-sys" 452 | version = "0.48.0" 453 | source = "registry+https://github.com/rust-lang/crates.io-index" 454 | checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" 455 | dependencies = [ 456 | "windows-targets 0.48.5", 457 | ] 458 | 459 | [[package]] 460 | name = "windows-sys" 461 | version = "0.52.0" 462 | source = "registry+https://github.com/rust-lang/crates.io-index" 463 | checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" 464 | dependencies = [ 465 | "windows-targets 0.52.6", 466 | ] 467 | 468 | [[package]] 469 | name = "windows-targets" 470 | version = "0.48.5" 471 | source = "registry+https://github.com/rust-lang/crates.io-index" 472 | checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" 473 | dependencies = [ 474 | "windows_aarch64_gnullvm 0.48.5", 475 | "windows_aarch64_msvc 0.48.5", 476 | "windows_i686_gnu 0.48.5", 477 | "windows_i686_msvc 0.48.5", 478 | "windows_x86_64_gnu 0.48.5", 479 | "windows_x86_64_gnullvm 0.48.5", 480 | "windows_x86_64_msvc 0.48.5", 481 | ] 482 | 483 | [[package]] 484 | name = "windows-targets" 485 | version = "0.52.6" 486 | source = "registry+https://github.com/rust-lang/crates.io-index" 487 | checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" 488 | dependencies = [ 489 | "windows_aarch64_gnullvm 0.52.6", 490 | "windows_aarch64_msvc 0.52.6", 491 | "windows_i686_gnu 0.52.6", 492 | "windows_i686_gnullvm", 493 | "windows_i686_msvc 0.52.6", 494 | "windows_x86_64_gnu 0.52.6", 495 | "windows_x86_64_gnullvm 0.52.6", 496 | "windows_x86_64_msvc 0.52.6", 497 | ] 498 | 499 | [[package]] 500 | name = "windows_aarch64_gnullvm" 501 | version = "0.48.5" 502 | source = "registry+https://github.com/rust-lang/crates.io-index" 503 | checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" 504 | 505 | [[package]] 506 | name = "windows_aarch64_gnullvm" 507 | version = "0.52.6" 508 | source = "registry+https://github.com/rust-lang/crates.io-index" 509 | checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" 510 | 511 | [[package]] 512 | name = "windows_aarch64_msvc" 513 | version = "0.48.5" 514 | source = "registry+https://github.com/rust-lang/crates.io-index" 515 | checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" 516 | 517 | [[package]] 518 | name = "windows_aarch64_msvc" 519 | version = "0.52.6" 520 | source = "registry+https://github.com/rust-lang/crates.io-index" 521 | checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" 522 | 523 | [[package]] 524 | name = "windows_i686_gnu" 525 | version = "0.48.5" 526 | source = "registry+https://github.com/rust-lang/crates.io-index" 527 | checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" 528 | 529 | [[package]] 530 | name = "windows_i686_gnu" 531 | version = "0.52.6" 532 | source = "registry+https://github.com/rust-lang/crates.io-index" 533 | checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" 534 | 535 | [[package]] 536 | name = "windows_i686_gnullvm" 537 | version = "0.52.6" 538 | source = "registry+https://github.com/rust-lang/crates.io-index" 539 | checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" 540 | 541 | [[package]] 542 | name = "windows_i686_msvc" 543 | version = "0.48.5" 544 | source = "registry+https://github.com/rust-lang/crates.io-index" 545 | checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" 546 | 547 | [[package]] 548 | name = "windows_i686_msvc" 549 | version = "0.52.6" 550 | source = "registry+https://github.com/rust-lang/crates.io-index" 551 | checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" 552 | 553 | [[package]] 554 | name = "windows_x86_64_gnu" 555 | version = "0.48.5" 556 | source = "registry+https://github.com/rust-lang/crates.io-index" 557 | checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" 558 | 559 | [[package]] 560 | name = "windows_x86_64_gnu" 561 | version = "0.52.6" 562 | source = "registry+https://github.com/rust-lang/crates.io-index" 563 | checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" 564 | 565 | [[package]] 566 | name = "windows_x86_64_gnullvm" 567 | version = "0.48.5" 568 | source = "registry+https://github.com/rust-lang/crates.io-index" 569 | checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" 570 | 571 | [[package]] 572 | name = "windows_x86_64_gnullvm" 573 | version = "0.52.6" 574 | source = "registry+https://github.com/rust-lang/crates.io-index" 575 | checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" 576 | 577 | [[package]] 578 | name = "windows_x86_64_msvc" 579 | version = "0.48.5" 580 | source = "registry+https://github.com/rust-lang/crates.io-index" 581 | checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" 582 | 583 | [[package]] 584 | name = "windows_x86_64_msvc" 585 | version = "0.52.6" 586 | source = "registry+https://github.com/rust-lang/crates.io-index" 587 | checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" 588 | -------------------------------------------------------------------------------- /ws/Cargo.toml: -------------------------------------------------------------------------------- 1 | [workspace] 2 | resolver = "2" 3 | 4 | members = [ 5 | # Libraries 6 | # ... none yet ... 7 | 8 | # Binaries 9 | "obiwan", 10 | ] 11 | 12 | [workspace.package] 13 | version = "0.1.0" 14 | authors = ["Julian Stecklina "] 15 | edition = "2021" 16 | license = "AGPL-3.0-or-later" 17 | 18 | [profile.release] 19 | lto = true 20 | codegen-units = 1 21 | strip = true 22 | -------------------------------------------------------------------------------- /ws/obiwan/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "obiwan" 3 | version.workspace = true 4 | authors.workspace = true 5 | edition.workspace = true 6 | license.workspace = true 7 | 8 | [dependencies] 9 | log = "0.4.21" 10 | anyhow = "1.0.82" 11 | clap = { version = "4.5.4", default-features = false, features = [ "std", "help", "usage", "derive" ] } 12 | simplelog = { version = "0.12.2", default-features = false } 13 | nix = { version = "0.29.0", features = [ "user", "fs" ] } 14 | tokio = { version = "1.37.0", default-features = false, features = [ "fs", "io-util", "net", "rt", "sync", "time", "macros" ] } 15 | binrw = "0.14.0" 16 | async-trait = "0.1.80" 17 | -------------------------------------------------------------------------------- /ws/obiwan/src/main.rs: -------------------------------------------------------------------------------- 1 | mod path; 2 | mod simple_fs; 3 | mod simple_proto; 4 | mod tftp; 5 | mod tftp_proto; 6 | 7 | use std::{ 8 | net::SocketAddr, 9 | path::{Path, PathBuf}, 10 | time::Duration, 11 | }; 12 | 13 | use anyhow::{anyhow, Context, Result}; 14 | use clap::Parser; 15 | use log::{debug, error, info, trace, warn, LevelFilter}; 16 | use tokio::{runtime::Handle, time::timeout}; 17 | 18 | use crate::{ 19 | simple_proto::{ConnectionStatus, Event, SimpleUdpProtocol}, 20 | tftp_proto::Connection, 21 | }; 22 | 23 | /// A simple TFTP server for PXE booting 24 | #[derive(Parser, Debug)] 25 | #[command(author, version, about, long_about = None)] 26 | struct Args { 27 | /// Silence all output. 28 | #[structopt(short = 'q')] 29 | quiet: bool, 30 | 31 | /// Verbose mode. Specify multiple times to increase verbosity. 32 | #[arg(short = 'v', long, action = clap::ArgAction::Count)] 33 | verbose: u8, 34 | 35 | /// The user to drop privileges to when started as root. 36 | #[arg(long, default_value = "nobody")] 37 | unprivileged_user: String, 38 | 39 | /// The address to listen on. 40 | #[arg(short = 'l', long, default_value = "127.0.0.1:69")] 41 | listen_address: String, 42 | 43 | /// The directory to serve via TFTP. 44 | directory: PathBuf, 45 | } 46 | 47 | /// Try to revoke privileges. This may or may not succeed depending on 48 | /// our privileges. 49 | /// 50 | /// The returned path is refers to the passed directory and is 51 | /// modified depending on whether we managed to actually change to a 52 | /// new root directory. 53 | fn drop_privileges(unprivileged_user: &str, directory: &Path) -> Result { 54 | use nix::{ 55 | errno::Errno, 56 | libc::{prctl, PR_SET_NO_NEW_PRIVS}, 57 | unistd::{chroot, geteuid, setuid, User}, 58 | }; 59 | 60 | // prctl has no clear safety requirements, but we use it as the C 61 | // man page intends it to be used. 62 | match unsafe { prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) } { 63 | 0 => info!("Applied NO_NEW_PRIVS."), 64 | e => warn!("Failed to apply NO_NEW_PRIVS. Error: {e}"), 65 | } 66 | 67 | // We need to lookup the user before chroot, otherwise the user db is gone. 68 | let unprivileged_uid = User::from_name(unprivileged_user) 69 | .context("Failed to lookup unprivileged user")? 70 | .ok_or_else(|| anyhow!("Failed to look up unprivileged user. Does it exist?"))? 71 | .uid; 72 | 73 | let new_root = match chroot(directory) { 74 | Ok(_) => { 75 | info!("Changed root directory to: {}", directory.display()); 76 | Ok("/".into()) 77 | } 78 | Err(Errno::EPERM) => { 79 | warn!("Can't drop filesystem privileges due to insufficient permissions. Start as root or with CAP_SYS_CHROOT, if this is desired."); 80 | Ok(directory.to_owned()) 81 | } 82 | Err(e) => Err(e).context("Failed to chroot to directory"), 83 | }?; 84 | 85 | if geteuid().is_root() { 86 | setuid(unprivileged_uid).context("Failed to drop privileges")?; 87 | info!("Dropped privileges to user '{}'.", unprivileged_user); 88 | } else { 89 | info!( 90 | "Will not drop privileges to {}, because we are not running as root.", 91 | unprivileged_user 92 | ); 93 | } 94 | 95 | Ok(new_root) 96 | } 97 | 98 | /// Sets the port of a socket address to zero. This is useful to let 99 | /// the OS choose the port number for us. 100 | fn clear_port(mut addr: SocketAddr) -> SocketAddr { 101 | addr.set_port(0); 102 | addr 103 | } 104 | 105 | async fn send_packet(socket: &tokio::net::UdpSocket, packet: tftp::Packet) -> Result<()> { 106 | trace!("{packet:?}"); 107 | socket.send(&packet.to_vec()).await?; 108 | 109 | Ok(()) 110 | } 111 | 112 | async fn recv_packet( 113 | socket: &tokio::net::UdpSocket, 114 | recv_timeout: Duration, 115 | ) -> Result> { 116 | let mut buf = vec![0u8; 1 << 16]; 117 | 118 | match timeout(recv_timeout, socket.recv(&mut buf)).await { 119 | Ok(res) => Some(res?), 120 | Err(_) => None, 121 | } 122 | .map(|len| tftp::Packet::try_from(&buf[0..len]).context("Failed to parse incoming packet")) 123 | .transpose() 124 | } 125 | 126 | async fn handle_connection( 127 | local_addr: SocketAddr, 128 | remote_addr: SocketAddr, 129 | root: &Path, 130 | initial_request: tftp::Packet, 131 | ) -> Result<()> { 132 | debug!("{remote_addr}: Establishing new connection."); 133 | trace!("{remote_addr}: {initial_request:?}"); 134 | 135 | let socket = tokio::net::UdpSocket::bind(clear_port(local_addr)).await?; 136 | debug!("{remote_addr}: Local address: {}", socket.local_addr()?); 137 | 138 | socket.connect(remote_addr).await?; 139 | 140 | let mut con = Connection::new(root); 141 | let mut packet = Some(initial_request); 142 | 143 | loop { 144 | let response = con 145 | .handle_event(match packet { 146 | Some(p) => Event::PacketReceived(p), 147 | None => Event::Timeout, 148 | }) 149 | .await?; 150 | 151 | if let Some(p) = response.packet { 152 | send_packet(&socket, p).await?; 153 | } 154 | 155 | match response.next_status { 156 | ConnectionStatus::Terminated => break, 157 | ConnectionStatus::WaitingForPacket(timeout) => { 158 | packet = recv_packet(&socket, timeout).await?; 159 | } 160 | } 161 | } 162 | 163 | debug!("{remote_addr}: Connection terminated."); 164 | Ok(()) 165 | } 166 | 167 | async fn server_main(runtime: &Handle, socket: tokio::net::UdpSocket, root: &Path) -> Result<()> { 168 | let local_addr = socket.local_addr()?; 169 | let mut buf = vec![0u8; 1 << 16]; 170 | 171 | loop { 172 | let (len, remote_addr) = socket 173 | .recv_from(&mut buf) 174 | .await 175 | .context("Failed to read from UDP socket")?; 176 | 177 | match tftp::Packet::try_from(&buf[0..len]) { 178 | Ok(packet) => { 179 | let root = root.to_owned(); 180 | 181 | runtime.spawn(async move { 182 | if let Err(e) = handle_connection(local_addr, remote_addr, &root, packet).await 183 | { 184 | error!("Connection to {remote_addr} died due to an error: {e}"); 185 | } 186 | }); 187 | } 188 | Err(e) => warn!("Ignoring packet: {e}"), 189 | } 190 | } 191 | } 192 | 193 | fn main() -> Result<()> { 194 | let args = Args::parse(); 195 | 196 | simplelog::SimpleLogger::init( 197 | match args.verbose { 198 | 0 => LevelFilter::Warn, 199 | 1 => LevelFilter::Info, 200 | 2 => LevelFilter::Debug, 201 | _ => LevelFilter::Trace, 202 | }, 203 | simplelog::Config::default(), 204 | )?; 205 | 206 | info!("Hello!"); 207 | debug!("Command line parameters: {:?}", args); 208 | 209 | let socket = 210 | std::net::UdpSocket::bind(&args.listen_address).context("Failed to bind server port")?; 211 | 212 | // Because we create the socket without Tokio, we need to make 213 | // sure it is non-blocking. Otherwise, Tokio will hang when 214 | // reading from it and not schedule other tasks. 215 | socket.set_nonblocking(true)?; 216 | 217 | debug!("Opened server socket: {:?}", socket); 218 | 219 | let root_directory = drop_privileges(&args.unprivileged_user, &args.directory)?; 220 | 221 | let tokio_runtime = tokio::runtime::Builder::new_current_thread() 222 | .enable_all() 223 | .build() 224 | .context("Failed to start I/O engine")?; 225 | 226 | tokio_runtime.block_on(async { 227 | server_main( 228 | tokio_runtime.handle(), 229 | tokio::net::UdpSocket::from_std(socket)?, 230 | &root_directory, 231 | ) 232 | .await 233 | })?; 234 | 235 | info!("Graceful exit. Bye!"); 236 | Ok(()) 237 | } 238 | -------------------------------------------------------------------------------- /ws/obiwan/src/path.rs: -------------------------------------------------------------------------------- 1 | use std::path::{Path, PathBuf}; 2 | 3 | /// Collapse any '..' in a path and turn it into a relative path (i.e. strip any leading slash). 4 | /// 5 | /// If all '..' cannot be collapsed, this function returns `None`. 6 | pub fn normalize(path: &Path) -> Option { 7 | let collapsed = path.iter().fold(PathBuf::new(), |mut acc, c| { 8 | if c == "/" { 9 | // Skip to avoid making the path absolute. 10 | } else if c == ".." && acc.parent().is_some() { 11 | acc.pop(); 12 | } else { 13 | // This will still accumulate .. at the front of the path, 14 | // but we deal with this below. 15 | acc.push(c); 16 | } 17 | 18 | acc 19 | }); 20 | 21 | assert!(collapsed.is_relative()); 22 | 23 | if collapsed.starts_with("..") { 24 | None 25 | } else { 26 | Some(collapsed) 27 | } 28 | } 29 | 30 | #[cfg(test)] 31 | mod tests { 32 | use super::*; 33 | 34 | #[test] 35 | fn path_normalization() { 36 | let mut p = PathBuf::new(); 37 | p.push("foo"); 38 | 39 | assert!(p.is_relative()); 40 | 41 | assert_eq!(normalize(Path::new("")), Some(Path::new("").to_owned())); 42 | 43 | assert_eq!( 44 | normalize(Path::new("/foo/bar")), 45 | Some(Path::new("foo/bar").to_owned()) 46 | ); 47 | 48 | assert_eq!(normalize(Path::new("../a")), None); 49 | 50 | assert_eq!( 51 | normalize(Path::new("/foo/../bar/../")), 52 | Some(Path::new("").to_owned()) 53 | ); 54 | 55 | assert_eq!( 56 | normalize(Path::new("/foo/../bar/../b")), 57 | Some(Path::new("b").to_owned()) 58 | ); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /ws/obiwan/src/simple_fs.rs: -------------------------------------------------------------------------------- 1 | //! This module is a simple abstraction over the filesystem to the 2 | //! degree that the TFTP protocol will need. It's main purpose is to 3 | //! facilitate unit testing. 4 | 5 | use std::{fmt::Debug, io::SeekFrom, path::Path, sync::Arc}; 6 | 7 | use async_trait::async_trait; 8 | use tokio::{ 9 | io::{AsyncReadExt, AsyncSeekExt}, 10 | sync::Mutex, 11 | }; 12 | 13 | #[async_trait] 14 | pub trait File: Debug + Send + Sync + Sized + Clone { 15 | type Error: std::error::Error + Send + Sync + 'static; 16 | 17 | /// Reads as many bytes as possible into `buf`. Returns the number 18 | /// of bytes read. If less bytes are read than `buf` has space, the 19 | /// file has ended. 20 | async fn read(&self, offset: u64, buf: &mut [u8]) -> Result; 21 | 22 | /// Return the size of the file in bytes. 23 | async fn size(&self) -> Result; 24 | } 25 | 26 | #[async_trait] 27 | pub trait Filesystem: Debug + Send + Sync + Clone { 28 | type File: File; 29 | type Error: std::error::Error + Send + Sync + 'static; 30 | 31 | /// Open a file for reading. 32 | async fn open(&self, path: &Path) -> Result; 33 | } 34 | 35 | #[derive(Debug, Clone)] 36 | pub struct AsyncFile { 37 | file: Arc>, 38 | } 39 | 40 | impl From for AsyncFile { 41 | fn from(file: tokio::fs::File) -> Self { 42 | Self { 43 | file: Arc::new(Mutex::new(file)), 44 | } 45 | } 46 | } 47 | 48 | #[async_trait] 49 | impl File for AsyncFile { 50 | type Error = std::io::Error; 51 | 52 | async fn read(&self, offset: u64, buf: &mut [u8]) -> Result { 53 | let mut file = self.file.lock().await; 54 | 55 | file.seek(SeekFrom::Start(offset)).await?; 56 | 57 | let mut offset = 0; 58 | 59 | loop { 60 | let bytes_read = file.read(&mut buf[offset..]).await?; 61 | offset += bytes_read; 62 | 63 | if bytes_read == 0 || offset == buf.len() { 64 | break; 65 | } 66 | } 67 | 68 | Ok(offset) 69 | } 70 | 71 | async fn size(&self) -> Result { 72 | let file = self.file.lock().await; 73 | 74 | Ok(file.metadata().await?.len()) 75 | } 76 | } 77 | 78 | #[derive(Debug, Clone, Default)] 79 | pub struct AsyncFilesystem {} 80 | 81 | #[async_trait] 82 | impl Filesystem for AsyncFilesystem { 83 | type File = AsyncFile; 84 | type Error = std::io::Error; 85 | 86 | async fn open(&self, path: &Path) -> Result { 87 | tokio::fs::File::open(path).await.map(AsyncFile::from) 88 | } 89 | } 90 | 91 | #[cfg(test)] 92 | #[async_trait] 93 | impl File for Vec { 94 | type Error = std::io::Error; 95 | 96 | async fn read(&self, offset: u64, buf: &mut [u8]) -> Result { 97 | use std::io::ErrorKind; 98 | 99 | if offset 100 | >= u64::try_from(self.len()) 101 | .map_err(|_| ()) 102 | .map_err(|_| Self::Error::new(ErrorKind::Other, "Conversion error"))? 103 | { 104 | return Ok(0); 105 | } 106 | 107 | let offset = usize::try_from(offset) 108 | .map_err(|_| Self::Error::new(ErrorKind::Other, "Conversion error"))?; 109 | let len = buf.len().min(self.len() - offset); 110 | 111 | buf[..len].copy_from_slice(&self[offset..(offset + len)]); 112 | Ok(len) 113 | } 114 | 115 | async fn size(&self) -> Result { 116 | Ok(u64::try_from(self.len()).unwrap()) 117 | } 118 | } 119 | 120 | #[cfg(test)] 121 | pub type MapFilesystem = std::collections::BTreeMap>; 122 | 123 | #[cfg(test)] 124 | #[async_trait] 125 | impl Filesystem for MapFilesystem { 126 | type File = Vec; 127 | type Error = std::io::Error; 128 | 129 | async fn open(&self, path: &Path) -> Result { 130 | self.get(path) 131 | .ok_or(std::io::Error::from_raw_os_error(22)) 132 | .cloned() 133 | } 134 | } 135 | 136 | #[cfg(test)] 137 | mod tests { 138 | use std::{collections::BTreeMap, path::PathBuf, str::FromStr}; 139 | 140 | use super::*; 141 | 142 | #[tokio::test] 143 | async fn can_read_btree_fs() { 144 | let map: BTreeMap> = 145 | BTreeMap::from([(PathBuf::from_str("/foo").unwrap(), vec![1, 2, 3, 4])]); 146 | 147 | let file = map 148 | .open(Path::new("/foo")) 149 | .await 150 | .expect("Failed to open file"); 151 | 152 | let mut buf = [0; 64]; 153 | 154 | assert_eq!(file.read(300, &mut buf).await.unwrap(), 0); // EOF 155 | 156 | assert_eq!(file.read(0, &mut buf).await.unwrap(), 4); 157 | assert_eq!(&buf[0..4], &[1, 2, 3, 4]); 158 | 159 | assert_eq!(file.read(3, &mut buf).await.unwrap(), 1); 160 | assert_eq!(&buf[0..1], &[4]); 161 | 162 | assert_eq!(file.size().await.unwrap(), 4); 163 | } 164 | } 165 | -------------------------------------------------------------------------------- /ws/obiwan/src/simple_proto.rs: -------------------------------------------------------------------------------- 1 | //! This module contains data structure to model a simple UDP 2 | //! protocol. 3 | //! 4 | //! The abstraction aims to make unit testing for simple UDP protocols 5 | //! easy. 6 | 7 | use std::{fmt::Debug, time::Duration}; 8 | 9 | use async_trait::async_trait; 10 | 11 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] 12 | pub enum ConnectionStatus { 13 | // The connection is terminated. 14 | Terminated, 15 | 16 | // We are waiting for a packet to arrive in the given 17 | // timeframe. If it doesn't a timeout event is generated. 18 | WaitingForPacket(Duration), 19 | } 20 | 21 | #[derive(Debug, Clone, PartialEq, Eq)] 22 | pub enum Event { 23 | // The given packet was received on this connection. 24 | PacketReceived(T), 25 | 26 | // We timed out waiting for a packet to arrive. 27 | Timeout, 28 | } 29 | 30 | #[derive(Debug, Clone, PartialEq, Eq)] 31 | pub struct Response { 32 | pub packet: Option, 33 | pub next_status: ConnectionStatus, 34 | } 35 | 36 | #[async_trait] 37 | pub trait SimpleUdpProtocol { 38 | type Packet: Debug + Clone + PartialEq + Eq; 39 | type Error; 40 | 41 | async fn handle_event( 42 | &mut self, 43 | event: Event, 44 | ) -> Result, Self::Error>; 45 | } 46 | -------------------------------------------------------------------------------- /ws/obiwan/src/tftp.rs: -------------------------------------------------------------------------------- 1 | //! This module implements data structure for the TFTP protocol. 2 | //! 3 | //! See [RFC 1350](https://datatracker.ietf.org/doc/html/rfc1350) for 4 | //! the basic protocol. [RFC 5 | //! 1782](https://datatracker.ietf.org/doc/html/rfc1782) covers the 6 | //! option extension to the protocol. 7 | 8 | use std::{ 9 | error::Error, 10 | ffi::{OsStr, OsString}, 11 | fmt::Display, 12 | io::Cursor, 13 | os::unix::prelude::{OsStrExt, OsStringExt}, 14 | path::PathBuf, 15 | }; 16 | 17 | use binrw::{binrw, helpers::until_eof, BinReaderExt, BinWriterExt, NullString}; 18 | 19 | /// TFTP error constants as defined by the RFC. 20 | #[allow(dead_code)] 21 | pub mod error { 22 | pub const UNDEFINED: u16 = 0; 23 | pub const FILE_NOT_FOUND: u16 = 1; 24 | pub const ACCESS_VIOLATION: u16 = 2; 25 | pub const DISK_FULL: u16 = 3; 26 | pub const ILLEGAL_OPERATION: u16 = 4; 27 | pub const UNKNOWN_TRANSFER_ID: u16 = 5; 28 | pub const FILE_EXISTS: u16 = 6; 29 | pub const NO_SUCH_USER: u16 = 7; 30 | pub const INVALID_OPTION: u16 = 8; 31 | } 32 | 33 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] 34 | pub enum RequestMode { 35 | Octet, 36 | Netascii, 37 | } 38 | 39 | #[derive(Debug, Clone, PartialEq, Eq)] 40 | pub struct RequestOption { 41 | pub name: String, 42 | pub value: String, 43 | } 44 | 45 | /// A TFTP protocol packet 46 | #[derive(Debug, Clone, PartialEq, Eq)] 47 | pub enum Packet { 48 | Rrq { 49 | filename: PathBuf, 50 | mode: RequestMode, 51 | options: Vec, 52 | }, 53 | Wrq { 54 | filename: PathBuf, 55 | mode: RequestMode, 56 | options: Vec, 57 | }, 58 | Data { 59 | block: u16, 60 | data: Vec, 61 | }, 62 | Ack { 63 | block: u16, 64 | }, 65 | Error { 66 | error_code: u16, 67 | error_msg: String, 68 | }, 69 | OAck { 70 | options: Vec, 71 | }, 72 | } 73 | 74 | #[binrw] 75 | #[brw(big)] 76 | struct ProtoOption { 77 | name: NullString, 78 | value: NullString, 79 | } 80 | 81 | #[binrw] 82 | #[brw(big)] 83 | enum ProtoPacket { 84 | #[brw(magic(1u16))] 85 | Rrq { 86 | filename: NullString, 87 | mode: NullString, 88 | #[br(parse_with = until_eof)] 89 | options: Vec, 90 | }, 91 | #[brw(magic(2u16))] 92 | Wrq { 93 | filename: NullString, 94 | mode: NullString, 95 | #[br(parse_with = until_eof)] 96 | options: Vec, 97 | }, 98 | #[brw(magic(3u16))] 99 | Data { 100 | block: u16, 101 | #[br(parse_with = until_eof)] 102 | data: Vec, 103 | }, 104 | #[brw(magic(4u16))] 105 | Ack { block: u16 }, 106 | #[brw(magic(5u16))] 107 | Error { 108 | error_code: u16, 109 | error_msg: NullString, 110 | }, 111 | #[brw(magic(6u16))] 112 | OAck { 113 | #[br(parse_with = until_eof)] 114 | options: Vec, 115 | }, 116 | } 117 | 118 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] 119 | pub enum ParseError { 120 | UnrecognizedPacket, 121 | InvalidString, 122 | InvalidMode, 123 | } 124 | 125 | impl Display for ParseError { 126 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 127 | match self { 128 | ParseError::InvalidString => { 129 | write!(f, "The packet contained a string that is not valid UTF-8") 130 | } 131 | ParseError::UnrecognizedPacket => { 132 | write!(f, "Failed to parse a packet") 133 | } 134 | ParseError::InvalidMode => { 135 | write!( 136 | f, 137 | "Failed to parse the packet because of an invalid mode string" 138 | ) 139 | } 140 | } 141 | } 142 | } 143 | 144 | impl Error for ParseError {} 145 | 146 | fn mode_from_u8(input: &[u8]) -> Result { 147 | let mode_str = OsStr::from_bytes(input); 148 | 149 | if mode_str.eq_ignore_ascii_case("netascii") { 150 | Ok(RequestMode::Netascii) 151 | } else if mode_str.eq_ignore_ascii_case("octet") { 152 | Ok(RequestMode::Octet) 153 | } else { 154 | Err(ParseError::InvalidMode) 155 | } 156 | } 157 | 158 | fn mode_to_u8(mode: RequestMode) -> Vec { 159 | match mode { 160 | RequestMode::Octet => b"octet".to_vec(), 161 | RequestMode::Netascii => b"netascii".to_vec(), 162 | } 163 | } 164 | 165 | fn string_from_u8(input: &[u8]) -> Result { 166 | std::str::from_utf8(input) 167 | .map_err(|_| ParseError::InvalidString) 168 | .map(|s| s.to_owned()) 169 | } 170 | 171 | fn option_from_proto(proto_option: &ProtoOption) -> Result { 172 | Ok(RequestOption { 173 | name: string_from_u8(&proto_option.name)?, 174 | value: string_from_u8(&proto_option.value)?, 175 | }) 176 | } 177 | 178 | fn options_from_proto(proto_options: &[ProtoOption]) -> Result, ParseError> { 179 | proto_options.iter().map(option_from_proto).collect() 180 | } 181 | 182 | fn option_to_proto(option: &RequestOption) -> ProtoOption { 183 | ProtoOption { 184 | name: NullString(option.name.clone().into_bytes()), 185 | value: NullString(option.value.clone().into_bytes()), 186 | } 187 | } 188 | 189 | fn options_to_proto(options: &[RequestOption]) -> Vec { 190 | options.iter().map(option_to_proto).collect() 191 | } 192 | 193 | impl Packet { 194 | pub fn to_vec(&self) -> Vec { 195 | let proto_packet = match self { 196 | Packet::Rrq { 197 | filename, 198 | mode, 199 | options, 200 | } => ProtoPacket::Rrq { 201 | filename: NullString(filename.clone().into_os_string().into_vec()), 202 | mode: NullString(mode_to_u8(*mode)), 203 | options: options_to_proto(options), 204 | }, 205 | Packet::Wrq { 206 | filename, 207 | mode, 208 | options, 209 | } => ProtoPacket::Wrq { 210 | filename: NullString(filename.clone().into_os_string().into_vec()), 211 | mode: NullString(mode_to_u8(*mode)), 212 | options: options_to_proto(options), 213 | }, 214 | Packet::Data { block, data } => ProtoPacket::Data { 215 | block: *block, 216 | data: data.clone(), 217 | }, 218 | Packet::Ack { block } => ProtoPacket::Ack { block: *block }, 219 | Packet::Error { 220 | error_code, 221 | error_msg, 222 | } => ProtoPacket::Error { 223 | error_code: *error_code, 224 | error_msg: error_msg.clone().into(), 225 | }, 226 | Packet::OAck { options } => ProtoPacket::OAck { 227 | options: options_to_proto(options), 228 | }, 229 | }; 230 | 231 | let mut cur = Cursor::new(Vec::new()); 232 | cur.write_be(&proto_packet).unwrap(); 233 | cur.into_inner() 234 | } 235 | } 236 | 237 | impl TryFrom<&[u8]> for Packet { 238 | type Error = ParseError; 239 | 240 | fn try_from(input: &[u8]) -> Result { 241 | let proto_packet: ProtoPacket = Cursor::new(input) 242 | .read_be() 243 | .map_err(|_| ParseError::UnrecognizedPacket)?; 244 | 245 | let packet = match proto_packet { 246 | ProtoPacket::Rrq { 247 | filename, 248 | mode, 249 | options, 250 | } => { 251 | Packet::Rrq { 252 | // We avoid going through String to accept filenames 253 | // with invalid UTF-8. While the TFTP spec only allows 254 | // plain ASCII filenames, this is not the reality on a 255 | // modern Linux system. 256 | filename: PathBuf::from(OsString::from_vec(filename.to_vec())), 257 | mode: mode_from_u8(&mode)?, 258 | options: options_from_proto(&options)?, 259 | } 260 | } 261 | ProtoPacket::Wrq { 262 | filename, 263 | mode, 264 | options, 265 | } => Packet::Wrq { 266 | // See the comment in Rrq above. 267 | filename: PathBuf::from(OsString::from_vec(filename.to_vec())), 268 | mode: mode_from_u8(&mode)?, 269 | options: options_from_proto(&options)?, 270 | }, 271 | ProtoPacket::Data { block, data } => Packet::Data { block, data }, 272 | ProtoPacket::Ack { block } => Packet::Ack { block }, 273 | ProtoPacket::Error { 274 | error_code, 275 | error_msg, 276 | } => Packet::Error { 277 | error_code, 278 | error_msg: String::from_utf8(error_msg.to_vec()) 279 | .map_err(|_| ParseError::InvalidString)?, 280 | }, 281 | ProtoPacket::OAck { options } => Packet::OAck { 282 | options: options_from_proto(&options)?, 283 | }, 284 | }; 285 | 286 | Ok(packet) 287 | } 288 | } 289 | 290 | #[cfg(test)] 291 | mod tests { 292 | use super::*; 293 | 294 | use std::str::FromStr; 295 | 296 | #[test] 297 | fn parse_rrq_without_options() { 298 | assert_eq!( 299 | Packet::try_from(b"\x00\x01\0octet\0".as_ref()), 300 | Ok(Packet::Rrq { 301 | filename: PathBuf::from_str("").unwrap(), 302 | mode: RequestMode::Octet, 303 | options: vec![] 304 | }) 305 | ); 306 | 307 | assert_eq!( 308 | Packet::try_from(b"\x00\x01foo\0NeTAscIi\0".as_ref()), 309 | Ok(Packet::Rrq { 310 | filename: PathBuf::from_str("foo").unwrap(), 311 | mode: RequestMode::Netascii, 312 | options: vec![] 313 | }) 314 | ); 315 | 316 | assert_eq!( 317 | Packet::try_from(b"\x00\x01zOo\0oCtet\0".as_ref()), 318 | Ok(Packet::Rrq { 319 | filename: PathBuf::from_str("zOo").unwrap(), 320 | mode: RequestMode::Octet, 321 | options: vec![] 322 | }) 323 | ) 324 | } 325 | 326 | #[test] 327 | fn serialize_rrq_without_options() { 328 | assert_eq!( 329 | (Packet::Rrq { 330 | filename: PathBuf::from_str("").unwrap(), 331 | mode: RequestMode::Octet, 332 | options: vec![] 333 | }) 334 | .to_vec(), 335 | b"\x00\x01\0octet\0" 336 | ); 337 | 338 | assert_eq!( 339 | (Packet::Rrq { 340 | filename: PathBuf::from_str("zOo").unwrap(), 341 | mode: RequestMode::Octet, 342 | options: vec![] 343 | }) 344 | .to_vec(), 345 | b"\x00\x01zOo\0octet\0" 346 | ) 347 | } 348 | 349 | #[test] 350 | fn parse_rrq_with_options() { 351 | assert_eq!( 352 | Packet::try_from(b"\x00\x01\0octet\0key1\0value1\0key2\0value2\0".as_ref()), 353 | Ok(Packet::Rrq { 354 | filename: PathBuf::from_str("").unwrap(), 355 | mode: RequestMode::Octet, 356 | options: vec![ 357 | RequestOption { 358 | name: "key1".to_string(), 359 | value: "value1".to_string() 360 | }, 361 | RequestOption { 362 | name: "key2".to_string(), 363 | value: "value2".to_string() 364 | } 365 | ] 366 | }) 367 | ); 368 | } 369 | 370 | #[test] 371 | fn serialize_rrq_with_options() { 372 | assert_eq!( 373 | (Packet::Rrq { 374 | filename: PathBuf::from_str("").unwrap(), 375 | mode: RequestMode::Octet, 376 | options: vec![ 377 | RequestOption { 378 | name: "key1".to_string(), 379 | value: "value1".to_string() 380 | }, 381 | RequestOption { 382 | name: "key2".to_string(), 383 | value: "value2".to_string() 384 | } 385 | ] 386 | }) 387 | .to_vec(), 388 | b"\x00\x01\0octet\0key1\0value1\0key2\0value2\0" 389 | ); 390 | } 391 | 392 | #[test] 393 | fn parse_wrq_without_options() { 394 | assert_eq!( 395 | Packet::try_from(b"\x00\x02\0octet\0".as_ref()), 396 | Ok(Packet::Wrq { 397 | filename: PathBuf::from_str("").unwrap(), 398 | mode: RequestMode::Octet, 399 | options: vec![] 400 | }) 401 | ); 402 | 403 | assert_eq!( 404 | Packet::try_from(b"\x00\x02foo\0NeTAscIi\0".as_ref()), 405 | Ok(Packet::Wrq { 406 | filename: PathBuf::from_str("foo").unwrap(), 407 | mode: RequestMode::Netascii, 408 | options: vec![] 409 | }) 410 | ); 411 | 412 | assert_eq!( 413 | Packet::try_from(b"\x00\x02zOo\0oCtet\0".as_ref()), 414 | Ok(Packet::Wrq { 415 | filename: PathBuf::from_str("zOo").unwrap(), 416 | mode: RequestMode::Octet, 417 | options: vec![] 418 | }) 419 | ) 420 | } 421 | 422 | #[test] 423 | fn serialize_wrq_without_options() { 424 | assert_eq!( 425 | (Packet::Wrq { 426 | filename: PathBuf::from_str("").unwrap(), 427 | mode: RequestMode::Octet, 428 | options: vec![] 429 | }) 430 | .to_vec(), 431 | b"\x00\x02\0octet\0", 432 | ); 433 | 434 | assert_eq!( 435 | (Packet::Wrq { 436 | filename: PathBuf::from_str("foo").unwrap(), 437 | mode: RequestMode::Netascii, 438 | options: vec![] 439 | }) 440 | .to_vec(), 441 | b"\x00\x02foo\0netascii\0", 442 | ); 443 | } 444 | 445 | #[test] 446 | fn parse_wrq_with_options() { 447 | assert_eq!( 448 | Packet::try_from(b"\x00\x02\0octet\0key1\0value1\0key2\0value2\0".as_ref()), 449 | Ok(Packet::Wrq { 450 | filename: PathBuf::from_str("").unwrap(), 451 | mode: RequestMode::Octet, 452 | options: vec![ 453 | RequestOption { 454 | name: "key1".to_string(), 455 | value: "value1".to_string() 456 | }, 457 | RequestOption { 458 | name: "key2".to_string(), 459 | value: "value2".to_string() 460 | } 461 | ] 462 | }) 463 | ); 464 | } 465 | 466 | #[test] 467 | fn serialize_wrq_with_options() { 468 | assert_eq!( 469 | (Packet::Wrq { 470 | filename: PathBuf::from_str("").unwrap(), 471 | mode: RequestMode::Octet, 472 | options: vec![ 473 | RequestOption { 474 | name: "key1".to_string(), 475 | value: "value1".to_string() 476 | }, 477 | RequestOption { 478 | name: "key2".to_string(), 479 | value: "value2".to_string() 480 | } 481 | ] 482 | }) 483 | .to_vec(), 484 | b"\x00\x02\0octet\0key1\0value1\0key2\0value2\0", 485 | ); 486 | } 487 | 488 | #[test] 489 | fn parse_data() { 490 | assert_eq!( 491 | Packet::try_from(b"\x00\x03\x12\x34hello world".as_ref()), 492 | Ok(Packet::Data { 493 | block: 0x1234, 494 | data: b"hello world".to_vec(), 495 | }) 496 | ) 497 | } 498 | 499 | #[test] 500 | fn serialize_data() { 501 | assert_eq!( 502 | (Packet::Data { 503 | block: 0x1234, 504 | data: b"hello world".to_vec(), 505 | }) 506 | .to_vec(), 507 | b"\x00\x03\x12\x34hello world", 508 | ) 509 | } 510 | 511 | #[test] 512 | fn parse_ack() { 513 | assert_eq!( 514 | Packet::try_from(b"\x00\x04\x12\x34".as_ref()), 515 | Ok(Packet::Ack { block: 0x1234 }) 516 | ) 517 | } 518 | 519 | #[test] 520 | fn serialize_ack() { 521 | assert_eq!( 522 | (Packet::Ack { block: 0x1234 }).to_vec(), 523 | b"\x00\x04\x12\x34", 524 | ) 525 | } 526 | 527 | #[test] 528 | fn parse_error() { 529 | assert_eq!( 530 | Packet::try_from(b"\x00\x05\x01\x02Some error!\0".as_ref()), 531 | Ok(Packet::Error { 532 | error_code: 0x0102, 533 | error_msg: "Some error!".to_owned() 534 | }) 535 | ) 536 | } 537 | 538 | #[test] 539 | fn serialize_error() { 540 | assert_eq!( 541 | (Packet::Error { 542 | error_code: 0x0102, 543 | error_msg: "Some error!".to_owned() 544 | }) 545 | .to_vec(), 546 | b"\x00\x05\x01\x02Some error!\0", 547 | ) 548 | } 549 | 550 | #[test] 551 | fn parse_oack() { 552 | assert_eq!( 553 | Packet::try_from(b"\x00\x06".as_ref()), 554 | Ok(Packet::OAck { options: vec![] }) 555 | ); 556 | 557 | assert_eq!( 558 | Packet::try_from(b"\x00\x06key1\0value1\0key2\0value2\0".as_ref()), 559 | Ok(Packet::OAck { 560 | options: vec![ 561 | RequestOption { 562 | name: "key1".to_string(), 563 | value: "value1".to_string() 564 | }, 565 | RequestOption { 566 | name: "key2".to_string(), 567 | value: "value2".to_string() 568 | } 569 | ] 570 | }) 571 | ); 572 | } 573 | 574 | #[test] 575 | fn serialize_oack() { 576 | assert_eq!((Packet::OAck { options: vec![] }).to_vec(), b"\x00\x06"); 577 | 578 | assert_eq!( 579 | (Packet::OAck { 580 | options: vec![ 581 | RequestOption { 582 | name: "key1".to_string(), 583 | value: "value1".to_string() 584 | }, 585 | RequestOption { 586 | name: "key2".to_string(), 587 | value: "value2".to_string() 588 | } 589 | ] 590 | }) 591 | .to_vec(), 592 | b"\x00\x06key1\0value1\0key2\0value2\0" 593 | ); 594 | } 595 | } 596 | -------------------------------------------------------------------------------- /ws/obiwan/src/tftp_proto.rs: -------------------------------------------------------------------------------- 1 | //! This module implements the TFTP protocol in terms of [`simple_proto`]. 2 | 3 | use std::{ 4 | path::{Path, PathBuf}, 5 | time::Duration, 6 | }; 7 | 8 | use crate::{ 9 | path::normalize, 10 | simple_fs::{self, File}, 11 | simple_proto::{self, ConnectionStatus, Event, Response}, 12 | tftp::{self, RequestOption}, 13 | }; 14 | 15 | use anyhow::{anyhow, Result}; 16 | use async_trait::async_trait; 17 | use log::{debug, error, info, warn}; 18 | 19 | const DEFAULT_TFTP_TIMEOUT: Duration = Duration::from_secs(1); 20 | const DEFAULT_TFTP_BLKSIZE: u16 = 512; 21 | 22 | /// How many times do we resend packets, if we don't get a response. 23 | const MAX_RETRANSMISSIONS: u32 = 5; 24 | 25 | /// The options sent by the client that we acknowledged. 26 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] 27 | struct AcceptedOptions { 28 | block_size: Option, 29 | transfer_size: Option, 30 | } 31 | 32 | impl AcceptedOptions { 33 | fn to_option_vec(self) -> Vec { 34 | let mut res = vec![]; 35 | 36 | if let Some(block_size) = self.block_size { 37 | res.push(RequestOption { 38 | name: "blksize".to_string(), 39 | value: block_size.to_string(), 40 | }) 41 | } 42 | 43 | if let Some(transfer_size) = self.transfer_size { 44 | res.push(RequestOption { 45 | name: "tsize".to_string(), 46 | value: transfer_size.to_string(), 47 | }) 48 | } 49 | 50 | res 51 | } 52 | } 53 | 54 | /// The current state of the TFTP connection. 55 | #[derive(Debug)] 56 | pub enum Connection { 57 | /// The connection is terminated. No further packets are expected. 58 | Dead, 59 | /// We haven't seen an initial packet yet. 60 | WaitingForInitialPacket { filesystem: FS, root: PathBuf }, 61 | 62 | /// We have sent an OACK packet and wait for the corresponding ACK with block 0. 63 | AcknowledgingOptions { 64 | file: FS::File, 65 | 66 | /// How many timeout events have we received for this packet. 67 | timeout_events: u32, 68 | 69 | /// The list of options that we want to acknowledge. 70 | acknowledged_options: Vec, 71 | 72 | /// The block size for data packets. 73 | block_size: u16, 74 | }, 75 | 76 | /// The client successfully requested a file and we have managed 77 | /// to open it. Now we are reading the contents. 78 | ReadingFile { 79 | file: FS::File, 80 | 81 | /// The last block we acked. Note that this is not `u16` as 82 | /// the block number in TFTP packets, because otherwise we 83 | /// would be limited to small packet sizes. 84 | last_acked_block: u64, 85 | 86 | /// How many timeout events have we received for the current block. 87 | timeout_events: u32, 88 | 89 | /// We are waiting for the last ACK. 90 | last_was_final: bool, 91 | 92 | /// The block size for data packets. This is negotiated via options when the connection is established. 93 | block_size: u16, 94 | }, 95 | } 96 | 97 | impl Connection { 98 | pub fn new_with_filesystem(filesystem: FS, root: impl AsRef) -> Self { 99 | Self::WaitingForInitialPacket { 100 | filesystem, 101 | root: root.as_ref().to_path_buf(), 102 | } 103 | } 104 | 105 | async fn read_block(file: &mut FS::File, block: u64, block_size: u16) -> Result> { 106 | assert!(block >= 1); 107 | 108 | let mut buf = vec![0; usize::from(block_size)]; 109 | 110 | let size = file 111 | .read((block - 1) * u64::try_from(block_size)?, &mut buf) 112 | .await?; 113 | 114 | Ok(buf[0..size].to_vec()) 115 | } 116 | 117 | async fn ignore_packet( 118 | file: FS::File, 119 | block: u64, 120 | timeouts: u32, 121 | last_was_final: bool, 122 | block_size: u16, 123 | ) -> Result<(Self, Response)> { 124 | Ok(( 125 | Self::ReadingFile { 126 | file, 127 | last_acked_block: block, 128 | timeout_events: timeouts, 129 | last_was_final, 130 | block_size, 131 | }, 132 | Response { 133 | packet: None, 134 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT), 135 | }, 136 | )) 137 | } 138 | 139 | /// Drop the connection without sending an error. 140 | fn drop_connection() -> Result<(Self, Response)> { 141 | Ok(( 142 | Self::Dead, 143 | Response { 144 | packet: None, 145 | next_status: ConnectionStatus::Terminated, 146 | }, 147 | )) 148 | } 149 | 150 | fn drop_connection_with_error>( 151 | error_code: u16, 152 | error_msg: S, 153 | ) -> Result<(Self, Response)> { 154 | let error_msg: String = error_msg.into(); 155 | 156 | warn!("Sending error to client: {error_code} {error_msg}"); 157 | 158 | Ok(( 159 | Self::Dead, 160 | Response { 161 | packet: Some(tftp::Packet::Error { 162 | error_code, 163 | error_msg, 164 | }), 165 | next_status: ConnectionStatus::Terminated, 166 | }, 167 | )) 168 | } 169 | 170 | async fn send_block( 171 | mut file: FS::File, 172 | block: u64, 173 | timeouts: u32, 174 | block_size: u16, 175 | ) -> Result<(Self, Response)> { 176 | assert!(block > 0); 177 | assert!(block_size > 0); 178 | 179 | let data = Self::read_block(&mut file, block, block_size).await?; 180 | assert!(data.len() <= usize::from(block_size)); 181 | 182 | Ok(( 183 | Self::ReadingFile { 184 | file, 185 | last_acked_block: block - 1, 186 | timeout_events: timeouts, 187 | last_was_final: data.len() < usize::from(block_size), 188 | block_size, 189 | }, 190 | Response { 191 | packet: Some(tftp::Packet::Data { 192 | block: u16::try_from(block & 0xffff).unwrap(), 193 | data, 194 | }), 195 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT), 196 | }, 197 | )) 198 | } 199 | 200 | async fn acknowledge_options( 201 | file: FS::File, 202 | acknowledged_options: Vec, 203 | timeout_events: u32, 204 | block_size: u16, 205 | ) -> Result<(Self, Response)> { 206 | Ok(( 207 | Self::AcknowledgingOptions { 208 | file, 209 | acknowledged_options: acknowledged_options.clone(), 210 | block_size, 211 | timeout_events, 212 | }, 213 | Response { 214 | packet: Some(tftp::Packet::OAck { 215 | options: acknowledged_options, 216 | }), 217 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT), 218 | }, 219 | )) 220 | } 221 | 222 | /// Take the client's proposed options and see what is useful for us. 223 | async fn accept_options(file: &FS::File, options: &[RequestOption]) -> AcceptedOptions { 224 | let mut block_size: Option = None; 225 | let mut transfer_size: Option = None; 226 | 227 | for option in options { 228 | if option.name.eq_ignore_ascii_case("blksize") { 229 | match option.value.parse::() { 230 | Ok(parsed_block_size) if (8..=65464).contains(&parsed_block_size) => { 231 | block_size = Some(parsed_block_size); 232 | } 233 | _ => { 234 | warn!("Ignoring invalid block size: {}", option.value); 235 | } 236 | } 237 | } else if option.name.eq_ignore_ascii_case("tsize") { 238 | match file.size().await { 239 | Ok(size) => transfer_size = Some(size), 240 | Err(e) => { 241 | error!("Failed to query size of file, ignoring TSIZE option: {e}"); 242 | } 243 | } 244 | } else { 245 | debug!("Ignoring unknown option {}={}", option.name, option.value); 246 | } 247 | } 248 | 249 | AcceptedOptions { 250 | block_size, 251 | transfer_size, 252 | } 253 | } 254 | 255 | async fn handle_initial_read( 256 | filesystem: FS, 257 | root: &Path, 258 | path: &Path, 259 | options: &[RequestOption], 260 | ) -> Result<(Self, Response)> { 261 | let local_path = root.join( 262 | normalize(path) 263 | .ok_or_else(|| anyhow!("Failed to normalize path: {}", path.display()))?, 264 | ); 265 | 266 | info!("TFTP READ {} -> {}", path.display(), local_path.display()); 267 | 268 | match filesystem.open(&local_path).await { 269 | Ok(file) => { 270 | let accepted_options = Self::accept_options(&file, options).await; 271 | 272 | let block_size = accepted_options.block_size.unwrap_or(DEFAULT_TFTP_BLKSIZE); 273 | let option_vec = accepted_options.to_option_vec(); 274 | 275 | debug!("Accepted these options: {option_vec:?}"); 276 | 277 | if option_vec.is_empty() { 278 | Self::send_block(file, 1, 0, block_size).await 279 | } else { 280 | Self::acknowledge_options(file, option_vec, 0, block_size).await 281 | } 282 | } 283 | Err(err) => Self::drop_connection_with_error( 284 | tftp::error::UNDEFINED, 285 | format!("Failed to open file {}: {err}", local_path.display()), 286 | ), 287 | } 288 | } 289 | 290 | async fn handle_initial_event( 291 | filesystem: FS, 292 | root: &Path, 293 | event: Event, 294 | ) -> Result<(Self, Response)> { 295 | match event { 296 | Event::PacketReceived(p) => match p { 297 | tftp::Packet::Rrq { 298 | filename, 299 | mode: _, 300 | options, 301 | } => Self::handle_initial_read(filesystem, root, &filename, &options).await, 302 | tftp::Packet::Wrq { .. } => Self::drop_connection_with_error( 303 | tftp::error::ACCESS_VIOLATION, 304 | "This server only supports reading files", 305 | ), 306 | _ => Self::drop_connection_with_error( 307 | tftp::error::ILLEGAL_OPERATION, 308 | "Initial request is not Rrq or Wrq", 309 | ), 310 | }, 311 | Event::Timeout => panic!("Can't receive timeout as initial event"), 312 | } 313 | } 314 | 315 | async fn handle_option_acknowledgement( 316 | file: FS::File, 317 | timeout_events: u32, 318 | acknowledged_options: Vec, 319 | block_size: u16, 320 | event: Event, 321 | ) -> Result<(Self, Response)> { 322 | match event { 323 | Event::PacketReceived(p) => match p { 324 | tftp::Packet::Ack { block: 0 } => Self::send_block(file, 1, 0, block_size).await, 325 | tftp::Packet::Error { 326 | error_code, 327 | error_msg, 328 | } => { 329 | warn!("Client declined options: {error_code} {error_msg}"); 330 | Self::drop_connection() 331 | } 332 | _ => Self::drop_connection_with_error( 333 | tftp::error::ILLEGAL_OPERATION, 334 | "Expected ACK 0 as OACK response", 335 | ), 336 | }, 337 | Event::Timeout => { 338 | if timeout_events >= MAX_RETRANSMISSIONS { 339 | warn!("Client timed out sending first ACK."); 340 | Self::drop_connection() 341 | } else { 342 | debug!("Timeout waiting for ACK for options, resending...",); 343 | 344 | Self::acknowledge_options( 345 | file, 346 | acknowledged_options, 347 | timeout_events, 348 | block_size, 349 | ) 350 | .await 351 | } 352 | } 353 | } 354 | } 355 | 356 | async fn handle_reading_file_event( 357 | file: FS::File, 358 | mut last_acked_block: u64, 359 | mut timeouts: u32, 360 | last_was_final: bool, 361 | block_size: u16, 362 | event: Event, 363 | ) -> Result<(Self, Response)> { 364 | match event { 365 | Event::PacketReceived(packet) => match packet { 366 | tftp::Packet::Ack { block } => { 367 | let expected_block = last_acked_block + 1; 368 | 369 | debug!("Client acknowledged block {block:#x}, we expect {expected_block:#x}."); 370 | 371 | if u64::from(block) == expected_block & 0xffff { 372 | timeouts = 0; 373 | last_acked_block += 1; 374 | 375 | if last_was_final { 376 | debug!("Successfully sent {last_acked_block} blocks."); 377 | return Self::drop_connection(); 378 | } 379 | } else { 380 | debug!("Unexpected ACK. Ignoring."); 381 | return Self::ignore_packet( 382 | file, 383 | last_acked_block, 384 | timeouts, 385 | last_was_final, 386 | block_size, 387 | ) 388 | .await; 389 | } 390 | } 391 | tftp::Packet::Error { 392 | error_code, 393 | error_msg, 394 | } => { 395 | warn!("Client sent error: {error_code} {error_msg}"); 396 | return Self::drop_connection(); 397 | } 398 | _ => { 399 | return Self::drop_connection_with_error( 400 | tftp::error::ILLEGAL_OPERATION, 401 | "Received unexpected packet. Closing connection.", 402 | ); 403 | } 404 | }, 405 | Event::Timeout => { 406 | timeouts += 1; 407 | 408 | if timeouts > MAX_RETRANSMISSIONS { 409 | warn!("Client timed out sending ACKs."); 410 | return Self::drop_connection(); 411 | } else { 412 | debug!( 413 | "Timeout waiting for ACK for block {:x}, resending...", 414 | last_acked_block + 1 415 | ); 416 | } 417 | } 418 | } 419 | 420 | debug!("Sending block {:x}.", last_acked_block + 1); 421 | Self::send_block(file, last_acked_block + 1, timeouts, block_size).await 422 | } 423 | } 424 | 425 | impl Connection { 426 | pub fn new(root: impl AsRef) -> Self { 427 | Self::new_with_filesystem(simple_fs::AsyncFilesystem::default(), root) 428 | } 429 | } 430 | 431 | #[async_trait] 432 | impl simple_proto::SimpleUdpProtocol for Connection { 433 | type Packet = tftp::Packet; 434 | type Error = anyhow::Error; 435 | 436 | async fn handle_event( 437 | &mut self, 438 | event: Event, 439 | ) -> Result, Self::Error> { 440 | let (new_self, response) = match self { 441 | Self::Dead => panic!( 442 | "Should not receive events on a dead connection: {:?}", 443 | event 444 | ), 445 | Self::WaitingForInitialPacket { filesystem, root } => { 446 | Self::handle_initial_event(filesystem.clone(), root, event).await? 447 | } 448 | Self::AcknowledgingOptions { 449 | file, 450 | timeout_events, 451 | acknowledged_options, 452 | block_size, 453 | } => { 454 | Self::handle_option_acknowledgement( 455 | file.clone(), 456 | *timeout_events, 457 | acknowledged_options.clone(), 458 | *block_size, 459 | event, 460 | ) 461 | .await? 462 | } 463 | Self::ReadingFile { 464 | file, 465 | last_acked_block, 466 | timeout_events, 467 | last_was_final, 468 | block_size, 469 | } => { 470 | Self::handle_reading_file_event( 471 | file.clone(), 472 | *last_acked_block, 473 | *timeout_events, 474 | *last_was_final, 475 | *block_size, 476 | event, 477 | ) 478 | .await? 479 | } 480 | }; 481 | 482 | *self = new_self; 483 | Ok(response) 484 | } 485 | } 486 | 487 | #[cfg(test)] 488 | mod tests { 489 | use std::{path::PathBuf, str::FromStr}; 490 | 491 | use crate::simple_proto::{ConnectionStatus, SimpleUdpProtocol}; 492 | 493 | use super::*; 494 | 495 | #[tokio::test] 496 | async fn simple_read() { 497 | let mut file_contents = [0xab_u8; 513].to_vec(); 498 | 499 | // Make the contents more interesting. 500 | file_contents[2] = 0x12; 501 | file_contents[512] = 0x23; 502 | 503 | let fs = simple_fs::MapFilesystem::from([( 504 | PathBuf::from_str("/foo").unwrap(), 505 | file_contents.clone(), 506 | )]); 507 | let mut con = Connection::new_with_filesystem(fs, "/"); 508 | 509 | assert_eq!( 510 | con.handle_event(Event::PacketReceived(tftp::Packet::Rrq { 511 | filename: PathBuf::from("/foo"), 512 | mode: tftp::RequestMode::Octet, 513 | options: vec![] 514 | })) 515 | .await 516 | .unwrap(), 517 | Response { 518 | packet: Some(tftp::Packet::Data { 519 | block: 1, 520 | data: file_contents[0..512].to_vec() 521 | }), 522 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT) 523 | } 524 | ); 525 | 526 | assert_eq!( 527 | con.handle_event(Event::PacketReceived(tftp::Packet::Ack { block: 1 })) 528 | .await 529 | .unwrap(), 530 | Response { 531 | packet: Some(tftp::Packet::Data { 532 | block: 2, 533 | data: file_contents[512..].to_vec() 534 | }), 535 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT) 536 | } 537 | ); 538 | } 539 | 540 | #[tokio::test] 541 | async fn read_with_custom_block_size() { 542 | let mut file_contents = [0xab_u8; 513].to_vec(); 543 | 544 | // Make the contents more interesting. 545 | file_contents[2] = 0x12; 546 | file_contents[512] = 0x23; 547 | 548 | let fs = simple_fs::MapFilesystem::from([( 549 | PathBuf::from_str("/foo").unwrap(), 550 | file_contents.clone(), 551 | )]); 552 | let mut con = Connection::new_with_filesystem(fs, "/"); 553 | 554 | assert_eq!( 555 | con.handle_event(Event::PacketReceived(tftp::Packet::Rrq { 556 | filename: PathBuf::from("/foo"), 557 | mode: tftp::RequestMode::Octet, 558 | options: vec![ 559 | (RequestOption { 560 | name: "blksize".to_string(), 561 | value: "10".to_string(), 562 | }) 563 | ] 564 | })) 565 | .await 566 | .unwrap(), 567 | Response { 568 | packet: Some(tftp::Packet::OAck { 569 | options: vec![ 570 | (RequestOption { 571 | name: "blksize".to_string(), 572 | value: "10".to_string(), 573 | }) 574 | ] 575 | }), 576 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT) 577 | } 578 | ); 579 | 580 | assert_eq!( 581 | con.handle_event(Event::PacketReceived(tftp::Packet::Ack { block: 0 })) 582 | .await 583 | .unwrap(), 584 | Response { 585 | packet: Some(tftp::Packet::Data { 586 | block: 1, 587 | data: file_contents[0..10].to_vec() 588 | }), 589 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT) 590 | } 591 | ); 592 | } 593 | 594 | #[tokio::test] 595 | async fn query_file_size() { 596 | let file_contents = [0xab_u8; 513].to_vec(); 597 | 598 | let fs = simple_fs::MapFilesystem::from([( 599 | PathBuf::from_str("/foo").unwrap(), 600 | file_contents.clone(), 601 | )]); 602 | let mut con = Connection::new_with_filesystem(fs, "/"); 603 | 604 | assert_eq!( 605 | con.handle_event(Event::PacketReceived(tftp::Packet::Rrq { 606 | filename: PathBuf::from("/foo"), 607 | mode: tftp::RequestMode::Octet, 608 | options: vec![ 609 | (RequestOption { 610 | name: "tsize".to_string(), 611 | value: "0".to_string(), 612 | }) 613 | ] 614 | })) 615 | .await 616 | .unwrap(), 617 | Response { 618 | packet: Some(tftp::Packet::OAck { 619 | options: vec![ 620 | (RequestOption { 621 | name: "tsize".to_string(), 622 | value: "513".to_string(), 623 | }) 624 | ] 625 | }), 626 | next_status: ConnectionStatus::WaitingForPacket(DEFAULT_TFTP_TIMEOUT) 627 | } 628 | ); 629 | } 630 | } 631 | -------------------------------------------------------------------------------- /ws/rustfmt.toml: -------------------------------------------------------------------------------- 1 | edition = "2021" 2 | --------------------------------------------------------------------------------