diff --git a/OpenRA.Mods.RA/Infiltrates.cs b/OpenRA.Mods.RA/Infiltrates.cs
index d315cccd9c..00d6a457ab 100644
--- a/OpenRA.Mods.RA/Infiltrates.cs
+++ b/OpenRA.Mods.RA/Infiltrates.cs
@@ -41,64 +41,84 @@ namespace OpenRA.Mods.RA
 			Info = info;
 		}
 
-		public IEnumerable<IOrderTargeter> Orders
-		{
-			get
-			{
-				yield return new InfiltratorOrderTargeter(CanInfiltrate);
-			}
-		}
+		public IEnumerable<IOrderTargeter> Orders { get { yield return new InfiltratorOrderTargeter(Info.Types); } }
 		
 		public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
 		{
-			if (order.OrderID == "Infiltrate")
-				return new Order(order.OrderID, self, queued) { TargetActor = target.Actor };
+			if (order.OrderID != "Infiltrate")
+				return null;
+
+			if (target.Type == TargetType.FrozenActor)
+				return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID };
 			
-			return null;
+			return new Order(order.OrderID, self, queued) { TargetActor = target.Actor };
 		}
 		
+		bool IsValidOrder(Actor self, Order order)
+		{
+			// Not targeting an actor
+			if (order.ExtraData == 0 && order.TargetActor == null)
+				return false;
+
+			if (order.ExtraData != 0)
+			{
+				// Targeted an actor under the fog
+				var frozenLayer = self.Owner.PlayerActor.TraitOrDefault<FrozenActorLayer>();
+				if (frozenLayer == null)
+					return false;
+
+				var frozen = frozenLayer.FromID(order.ExtraData);
+				if (frozen == null)
+					return false;
+
+				var ii = frozen.Info.Traits.GetOrDefault<InfiltratableInfo>();
+				return ii != null && Info.Types.Contains(ii.Type);
+			}
+
+			var i = order.TargetActor.Info.Traits.GetOrDefault<InfiltratableInfo>();
+			return i != null && Info.Types.Contains(i.Type);
+		}
+
 		public string VoicePhraseForOrder(Actor self, Order order)
 		{
-			return (order.OrderString == "Infiltrate" && CanInfiltrate(order.TargetActor)) ? "Attack" : null;
+			return order.OrderString == "Infiltrate" && IsValidOrder(self, order)
+			        ? "Attack" : null;
 		}
 		
 		public void ResolveOrder(Actor self, Order order)
 		{
-			if (order.OrderString == "Infiltrate")
-			{
-				if (!CanInfiltrate(order.TargetActor))
-					return;
+			if (order.OrderString != "Infiltrate" || !IsValidOrder(self, order))
+				return;
 
-				self.SetTargetLine(Target.FromOrder(order), Color.Red);
-				
+			var target = self.ResolveFrozenActorOrder(order, Color.Red);
+			if (target.Type != TargetType.Actor)
+				return;
+
+			if (!order.Queued)
 				self.CancelActivity();
-				self.QueueActivity(new Enter(order.TargetActor, new Infiltrate(order.TargetActor)));
-			}
-		}
-		
-		bool CanInfiltrate(Actor target)
-		{
-			var infiltratable = target.Info.Traits.GetOrDefault<InfiltratableInfo>();
-			return infiltratable != null && Info.Types.Contains(infiltratable.Type);
+
+			self.SetTargetLine(target, Color.Red);
+			self.QueueActivity(new Enter(target.Actor, new Infiltrate(target.Actor)));
 		}
 
 		class InfiltratorOrderTargeter : UnitOrderTargeter
 		{
-			readonly Func<Actor, bool> useEnterCursor;
-			
-			public InfiltratorOrderTargeter(Func<Actor, bool> useEnterCursor)
+			string[] infiltrationTypes;
+
+			public InfiltratorOrderTargeter(string[] infiltrationTypes)
 				: base("Infiltrate", 7, "enter", true, false)
 			{
 				ForceAttack = false;
-				this.useEnterCursor = useEnterCursor;
+				this.infiltrationTypes = infiltrationTypes;
 			}
 
 			public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
 			{
-				if (!target.HasTrait<IAcceptInfiltrator>())
+				var info = target.Info.Traits.GetOrDefault<InfiltratableInfo>();
+				if (info == null)
 					return false;
 
-				if (!useEnterCursor(target))
+				if (!infiltrationTypes.Contains(info.Type))
 					cursor = "enter-blocked";
 
 				return true;
@@ -106,8 +126,14 @@ namespace OpenRA.Mods.RA
 
 			public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
 			{
-				// TODO: Not yet supported
-				return false;
+				var info = target.Info.Traits.GetOrDefault<InfiltratableInfo>();
+				if (info == null)
+					return false;
+
+				if (!infiltrationTypes.Contains(info.Type))
+					cursor = "enter-blocked";
+
+				return true;
 			}
 		}
 	}
diff --git a/OpenRA.Mods.RA/Missions/Allies04Script.cs b/OpenRA.Mods.RA/Missions/Allies04Script.cs
index e66a5335fd..173d461f2a 100644
--- a/OpenRA.Mods.RA/Missions/Allies04Script.cs
+++ b/OpenRA.Mods.RA/Missions/Allies04Script.cs
@@ -457,7 +457,7 @@ namespace OpenRA.Mods.RA.Missions
 		}
 	}
 
-	class Allies04HijackableInfo : ITraitInfo
+	class Allies04HijackableInfo : ITraitInfo, Requires<InfiltratableInfo>
 	{
 		public object Create(ActorInitializer init) { return new Allies04Hijackable(init.self); }
 	}