▁sends ▁" rece ipt " ▁to ▁receiver ▁R . ▁Later , ▁C ▁sends ▁" open " ▁to ▁F , ▁which ▁sends ▁m ▁to ▁R . ▁ ▁Now , ▁assume ▁we ▁have ▁a ▁protocol ▁ π ▁that ▁real izes ▁this ▁functionality . ▁Suppose ▁that ▁the ▁comm itter ▁C ▁is ▁cor rupted . ▁In ▁the ▁U C ▁framework , ▁that ▁essentially ▁means ▁that ▁C ▁is ▁now ▁controlled ▁by ▁the ▁environment , ▁which ▁attempts ▁to ▁distinguish ▁protocol ▁execution ▁from ▁the ▁ideal ▁process . ▁Consider ▁an ▁environment ▁that ▁cho oses ▁a ▁message ▁m ▁and ▁then ▁tells ▁C ▁to ▁act ▁as ▁pres cribed ▁by ▁ π , ▁as ▁if ▁it ▁has ▁committed ▁to ▁m . ▁Note ▁here ▁that ▁in ▁order ▁to ▁realize ▁F , ▁the ▁receiver ▁must , ▁after ▁receiving ▁a ▁commit ment , ▁output ▁a ▁message ▁" rece ipt ". ▁After ▁the ▁environment ▁sees ▁this ▁message , ▁it ▁tells ▁C ▁to ▁open ▁the ▁commit ment . ▁ ▁The ▁protocol ▁is ▁only ▁secure ▁if ▁this ▁scenario ▁is ▁ind ist ingu ish able ▁from ▁the ▁ideal ▁case , ▁where ▁the ▁functionality ▁interact s ▁with ▁a ▁sim ulator ▁S . ▁Here , ▁S ▁has ▁control ▁of ▁C . ▁In ▁particular , ▁whenever ▁R ▁outputs ▁" rece ipt ", ▁F ▁has ▁to ▁do ▁like wise . ▁The ▁only ▁way ▁to ▁do ▁that ▁is ▁for ▁S ▁to ▁tell ▁C ▁to ▁send ▁a ▁value ▁to ▁F . ▁However , ▁note ▁that ▁by ▁this ▁point , ▁m ▁is ▁not ▁known ▁to ▁S . ▁Hence , ▁when ▁the ▁commit ment ▁is ▁opened ▁during ▁protocol ▁execution